Struct cli::client_proxy::ClientProxy

pub struct ClientProxy {
    pub chain_id: ChainId,
    pub client: DiemClient,
    pub accounts: Vec<AccountData>,
    pub diem_root_account: Option<AccountData>,
    pub tc_account: Option<AccountData>,
    pub testnet_designated_dealer_account: Option<AccountData>,
    pub quiet_wait: bool,
    pub wallet: WalletLibrary,
    pub url: Url,
    /* private fields */
}

Proxy handling CLI commands/inputs.

Fields

chain_id: ChainId

chain ID of the Diem network this client is interacting with

client: DiemClient

client for admission control interface.

accounts: Vec<AccountData>

Created accounts.

diem_root_account: Option<AccountData>

Account used for Diem Root operations (e.g., adding a new transaction script)

tc_account: Option<AccountData>

Account used for Treasury Compliance operations

testnet_designated_dealer_account: Option<AccountData>

Account used for “minting” operations

quiet_wait: bool

do not print ‘.’ when waiting for signed transaction

wallet: WalletLibrary

Wallet library managing user accounts.

url: Url

Host of the node that client connects to

Implementations

impl ClientProxy

pub fn new( chain_id: ChainId, url: &str, diem_root_account_file: &str, tc_account_file: &str, testnet_designated_dealer_account_file: &str, sync_on_wallet_recovery: bool, faucet_url: Option<String>, mnemonic_file: Option<String>, waypoint: Waypoint, quiet_wait: bool ) -> Result<Self>

Construct a new TestClient.

pub async fn streaming_client( &self, config: Option<StreamingClientConfig> ) -> StreamResult<StreamingClient>

Gets a websocket client for the same node DiemClient connects to

pub fn get_account(&self, address_num: usize) -> Option<&AccountData>

Gets account data for the indexed address

pub fn create_next_account( &mut self, sync_with_validator: bool ) -> Result<AddressAndIndex>

Returns the account index that should be used by user to reference this account

pub fn latest_epoch_change_li(&mut self) -> Option<&LedgerInfoWithSignatures>

Returns the ledger info corresonding to the latest epoch change (could further be used for e.g., generating a waypoint)

pub fn print_all_accounts(&self)

Print index and address of all accounts.

pub fn set_accounts( &mut self, accounts: Vec<AccountData> ) -> Vec<AddressAndIndex>

Set the account of this client instance.

pub fn get_balances( &mut self, space_delim_strings: &[&str] ) -> Result<Vec<String>>

Get balance from validator for the account specified.

pub fn get_sequence_number( &mut self, space_delim_strings: &[&str] ) -> Result<u64>

Get the latest sequence number from validator for the account specified.

pub fn add_currency( &mut self, space_delim_strings: &[&str], is_blocking: bool ) -> Result<()>

Adds a currency to the sending account. Fails if that currency already exists.

pub fn mint_coins( &mut self, space_delim_strings: &[&str], is_blocking: bool ) -> Result<()>

Mints coins for the receiver specified.

pub fn enable_custom_script( &mut self, space_delim_strings: &[&str], open_module: bool, is_blocking: bool ) -> Result<()>

Allow executing arbitrary script in the network.

pub fn change_diem_version( &mut self, space_delim_strings: &[&str], is_blocking: bool ) -> Result<()>

Modify the stored DiemVersion on chain.

pub fn upgrade_stdlib( &mut self, space_delim_strings: &[&str], is_blocking: bool ) -> Result<()>

Only allow executing predefined script in the Move standard library in the network.

pub fn wait_for_transaction( &self, address: AccountAddress, seq: u64 ) -> Result<()>

Wait for transaction, this function is not safe for waiting for a specific transaction, should use wait_for_signed_transaction instead. TODO: rename to wait_for_account_seq or remove

pub fn submit_and_wait( &mut self, txn: &SignedTransaction, is_blocking: bool ) -> Result<()>

Submit transaction and waits for the transaction executed

pub fn wait_for_signed_transaction( &mut self, txn: &SignedTransaction ) -> Result<TransactionView>

Waits for the transaction

pub fn transfer_coins_int( &mut self, sender_address: &AccountAddress, receiver_address: &AccountAddress, num_coins: u64, coin_currency: String, gas_unit_price: Option<u64>, gas_currency_code: Option<String>, max_gas_amount: Option<u64>, is_blocking: bool ) -> Result<IndexAndSequence>

Transfer num_coins from sender account to receiver. If is_blocking = true, it will keep querying validator till the sequence number is bumped up in validator.

pub fn prepare_transfer_coins( &mut self, sender_address: AccountAddress, sender_sequence_number: u64, receiver_address: AccountAddress, num_coins: u64, coin_currency: String, gas_unit_price: Option<u64>, max_gas_amount: Option<u64>, gas_currency_code: Option<String> ) -> Result<RawTransaction>

Prepare a transfer transaction: return the unsigned raw transaction

pub fn transfer_coins( &mut self, space_delim_strings: &[&str], is_blocking: bool ) -> Result<IndexAndSequence>

Transfers coins from sender to receiver.

pub fn compile_program( &mut self, space_delim_strings: &[&str] ) -> Result<Vec<String>>

Compile Move program

pub fn submit_signed_transaction( &mut self, raw_txn: RawTransaction, public_key: Ed25519PublicKey, signature: Ed25519Signature ) -> Result<()>

Submit a transaction to the network given the unsigned raw transaction, sender public key and signature

pub fn publish_module(&mut self, space_delim_strings: &[&str]) -> Result<()>

Publish Move module

pub fn execute_script(&mut self, space_delim_strings: &[&str]) -> Result<()>

Execute custom script

pub fn submit_writeset(&mut self, space_delim_strings: &[&str]) -> Result<()>

Submit a writeset transaction signed by local diem root account.

pub fn get_latest_account( &mut self, space_delim_strings: &[&str] ) -> Result<Option<AccountView>>

Get the latest account information from validator.

pub fn get_latest_version(&mut self) -> Version

Get the latest version

pub fn get_latest_account_resources( &mut self, space_delim_strings: &[&str] ) -> Result<(Option<AnnotatedAccountStateBlob>, Version)>

Get the latest annotated account resources from validator.

pub fn get_committed_txn_by_acc_seq( &mut self, space_delim_strings: &[&str] ) -> Result<Option<TransactionView>>

Get committed txn by account and sequence number.

pub fn get_committed_txn_by_range( &mut self, space_delim_strings: &[&str] ) -> Result<Vec<TransactionView>>

Get committed txn by account and sequence number

pub fn get_account_address_from_parameter( &self, para: &str ) -> Result<(AccountAddress, Option<AuthenticationKey>)>

Get account address and (if applicable) authentication key from parameter. If the parameter is string of address, try to convert it to address, otherwise, try to convert to u64 and looking at TestClient::accounts.

pub fn get_events_by_account_and_type( &mut self, space_delim_strings: &[&str] ) -> Result<(Vec<EventView>, AccountView)>

Get events by account and event type with start sequence number and limit.

pub fn write_recovery(&self, space_delim_strings: &[&str]) -> Result<()>

Write mnemonic recover to the file specified.

pub fn recover_wallet_accounts( &mut self, space_delim_strings: &[&str] ) -> Result<Vec<AddressAndIndex>>

Recover wallet accounts from command ‘recover ’ and return vec<(account_address, index)>.

pub fn recover_accounts_in_wallet(&mut self) -> Result<Vec<AddressAndIndex>>

Recover accounts in wallets and sync state if sync_on_wallet_recovery is true.

pub fn insert_account_data( &mut self, account_data: AccountData ) -> AddressAndIndex

Insert the account data to Client::accounts and return its address and index.s

pub fn test_validator_connection(&mut self) -> Result<MetadataView>

Test JSON RPC client connection with validator.

pub fn test_trusted_connection(&mut self) -> Result<()>

Test client’s connection to validator with proof.

pub fn association_transaction_with_local_diem_root_account( &mut self, payload: TransactionPayload, is_blocking: bool ) -> Result<()>

Send a transaction signed by the local diem_root credential

pub fn convert_to_scaled_representation( input: &str, scaling_factor: i64, fractional_part: i64 ) -> Result<u64>

Scale the number in input based on scaling_factor and ensure the fractional part is no less than fractional_part amount.

pub fn convert_to_on_chain_representation( &mut self, input: &str, currency: &str ) -> Result<u64>

convert number of coins (main unit) given as string to its on-chain representation