Struct TestCluster

pub struct TestCluster {
    pub swarm: Swarm,
    pub wallet: WalletContext,
    pub fullnode_handle: FullNodeHandle,
    /* private fields */
}

Fields

swarm: Swarm

wallet: WalletContext

fullnode_handle: FullNodeHandle

Implementations

impl TestCluster

pub fn rpc_client(&self) -> &HttpClient

pub fn sui_client(&self) -> &SuiClient

pub fn rpc_url(&self) -> &str

pub fn quorum_driver_api(&self) -> &QuorumDriverApi

pub fn wallet(&mut self) -> &WalletContext

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

pub fn get_addresses(&self) -> Vec<SuiAddress>

pub fn get_address_0(&self) -> SuiAddress

pub fn get_address_1(&self) -> SuiAddress

pub fn get_address_2(&self) -> SuiAddress

pub fn fullnode_config_builder(&self) -> FullnodeConfigBuilder

pub fn committee(&self) -> Arc<Committee>

pub async fn spawn_new_fullnode(&mut self) -> FullNodeHandle

Convenience method to start a new fullnode in the test cluster.

pub async fn start_fullnode_from_config( &mut self, config: NodeConfig, ) -> FullNodeHandle

pub fn all_node_handles(&self) -> Vec<SuiNodeHandle>

pub fn all_validator_handles(&self) -> Vec<SuiNodeHandle>

pub fn get_validator_pubkeys(&self) -> Vec<AuthorityName>

pub fn get_genesis(&self) -> Genesis

pub fn stop_node(&self, name: &AuthorityName)

pub async fn stop_all_validators(&self)

pub async fn start_all_validators(&self)

pub async fn start_node(&self, name: &AuthorityName)

pub async fn spawn_new_validator( &mut self, genesis_config: ValidatorGenesisConfig, ) -> SuiNodeHandle

pub fn random_node_restarter(self: &Arc<Self>) -> RandomNodeRestarter

pub async fn get_reference_gas_price(&self) -> u64

pub async fn get_object_from_fullnode_store( &self, object_id: &ObjectID, ) -> Option<Object>

pub async fn get_latest_object_ref(&self, object_id: &ObjectID) -> ObjectRef

pub async fn get_object_or_tombstone_from_fullnode_store( &self, object_id: ObjectID, ) -> ObjectRef

pub async fn wait_for_run_with_range_shutdown_signal( &self, ) -> Option<RunWithRange>

pub async fn wait_for_run_with_range_shutdown_signal_with_timeout( &self, timeout_dur: Duration, ) -> Option<RunWithRange>

pub async fn wait_for_protocol_version( &self, target_protocol_version: ProtocolVersion, ) -> SuiSystemState

pub async fn wait_for_protocol_version_with_timeout( &self, target_protocol_version: ProtocolVersion, timeout_dur: Duration, ) -> SuiSystemState

pub async fn trigger_reconfiguration(&self)

Ask 2f+1 validators to close epoch actively, and wait for the entire network to reach the next epoch. This requires waiting for both the fullnode and all validators to reach the next epoch.

pub async fn wait_for_epoch( &self, target_epoch: Option<EpochId>, ) -> SuiSystemState

To detect whether the network has reached such state, we use the fullnode as the source of truth, since a fullnode only does epoch transition when the network has done so. If target_epoch is specified, wait until the cluster reaches that epoch. If target_epoch is None, wait until the cluster reaches the next epoch. Note that this function does not guarantee that every node is at the target epoch.

pub async fn wait_for_epoch_on_node( &self, handle: &SuiNodeHandle, target_epoch: Option<EpochId>, timeout_dur: Duration, ) -> SuiSystemState

pub async fn wait_for_epoch_with_timeout( &self, target_epoch: Option<EpochId>, timeout_dur: Duration, ) -> SuiSystemState

pub async fn wait_for_epoch_all_nodes(&self, target_epoch: EpochId)

pub async fn update_validator_supported_versions( &self, new_supported_versions: SupportedProtocolVersions, )

Upgrade the network protocol version, by restarting every validator with a new supported versions. Note that we don’t restart the fullnode here, and it is assumed that the fulnode supports the entire version range.

pub async fn wait_for_all_nodes_upgrade_to(&self, protocol_version: u64)

Wait for all nodes in the network to upgrade to protocol_version.

pub async fn wait_for_authenticator_state_update(&self)

pub fn highest_protocol_version(&self) -> ProtocolVersion

Return the highest observed protocol version in the test cluster.

pub async fn test_transaction_builder(&self) -> TestTransactionBuilder

pub async fn test_transaction_builder_with_sender( &self, sender: SuiAddress, ) -> TestTransactionBuilder

pub async fn test_transaction_builder_with_gas_object( &self, sender: SuiAddress, gas: ObjectRef, ) -> TestTransactionBuilder

pub fn sign_transaction(&self, tx_data: &TransactionData) -> Transaction

pub async fn sign_and_execute_transaction( &self, tx_data: &TransactionData, ) -> SuiTransactionBlockResponse

pub async fn execute_transaction( &self, tx: Transaction, ) -> SuiTransactionBlockResponse

Execute a transaction on the network and wait for it to be executed on the rpc fullnode. Also expects the effects status to be ExecutionStatus::Success. This function is recommended for transaction execution since it most resembles the production path.

pub async fn execute_transaction_return_raw_effects( &self, tx: Transaction, ) -> Result<(TransactionEffects, TransactionEvents)>

Different from execute_transaction which returns RPC effects types, this function returns raw effects, events and extra objects returned by the validators, aggregated manually (without authority aggregator). It also does not check whether the transaction is executed successfully. In order to keep the fullnode up-to-date so that latter queries can read consistent results, it calls execute_transaction_may_fail again which goes through fullnode. This is less efficient and verbose, but can be used if more details are needed from the execution results, and if the transaction is expected to fail.

pub fn authority_aggregator( &self, ) -> Arc<AuthorityAggregator<NetworkAuthorityClient>>

pub async fn create_certificate( &self, tx: Transaction, client_addr: Option<SocketAddr>, ) -> Result<CertifiedTransaction>

pub async fn submit_transaction_to_validators( &self, tx: Transaction, pubkeys: &[AuthorityName], ) -> Result<(TransactionEffects, TransactionEvents)>

Execute a transaction on specified list of validators, and bypassing authority aggregator. This allows us to obtain the return value directly from validators, so that we can access more information directly such as the original effects, events and extra objects returned. This also allows us to control which validator to send certificates to, which is useful in some tests.

pub async fn fund_address_and_return_gas( &self, rgp: u64, amount: Option<u64>, funding_address: SuiAddress, ) -> ObjectRef

This call sends some funds from the seeded address to the funding address for the given amount and returns the gas object ref. This is useful to construct transactions from the funding address.

pub async fn transfer_sui_must_exceed( &self, sender: SuiAddress, receiver: SuiAddress, amount: u64, ) -> ObjectID