Struct TestCluster 

pub struct TestCluster {
    pub swarm: Swarm,
    pub wallet: WalletContext,
    pub fullnode_handle: FullNodeHandle,
}

Fields

swarm: Swarm

wallet: WalletContext

fullnode_handle: FullNodeHandle

Implementations

impl TestCluster

pub fn rpc_client(&self) -> &HttpClient

👎Deprecated:

use grpc_client()

pub fn sui_client(&self) -> &SuiClient

👎Deprecated:

use grpc_client()

pub fn grpc_client(&self) -> Client

pub fn rpc_url(&self) -> &str

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 fn get_sui_system_state(&self) -> SuiSystemState

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

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

pub fn observer_node(&self) -> Option<&Node>

The observer fullnode of the cluster, when built with with_observer_fullnode(). The cluster deliberately does not hold a node handle for the observer: a handle keeps the running instance (and its open stores) alive, which prevents the simulator from restarting the node after a crash. Acquire a fresh handle via Node::get_node_handle() at the point of use and drop it promptly.

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 fn get_chain_identifier(&self) -> ChainIdentifier

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

Waits until every node advances to a strictly higher epoch than the one it is at when this is called. Unlike wait_for_epoch_all_nodes, which matches a target epoch exactly, this only requires forward progress, so it is safe when the cluster catches up through several epochs at once (e.g. recovering from a stall) and would blow past any fixed target.

pub fn subscribe_to_epoch_change(&self) -> Receiver<SuiSystemState>

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)

Wait until the on-chain authenticator state contains any active JWK.

pub async fn wait_for_authenticator_state_update_for_providers( &self, jwk_ids: &[JwkId], )

Wait until the on-chain authenticator state contains all the given JWK ids.

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 async fn sign_transaction(&self, tx_data: &TransactionData) -> Transaction

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

pub async fn sign_and_execute_transaction_directly( &self, tx_data: &TransactionData, ) -> SuiResult<(TransactionDigest, TransactionEffects)>

Sign and execute the transaction via direct validator submission, bypassing the fullnode.

pub async fn execute_transaction_directly( &self, tx: &Transaction, ) -> SuiResult<(TransactionDigest, TransactionEffects)>

Execute an already-signed transaction via direct validator submission, bypassing the fullnode.

pub async fn sign_and_execute_txns_in_soft_bundle( &self, txns: &[TransactionData], ) -> SuiResult<Vec<(TransactionDigest, TransactionEffects)>>

Sign and execute multiple transactions in a soft bundle. Soft bundles allow submitting multiple transactions together with best-effort ordering if they use the same gas price. Transactions in a soft bundle can be individually rejected or deferred without affecting other transactions.

NOTE: This is a simplified implementation that processes transactions individually. For true soft bundle submission, the test file should use the raw gRPC client directly with tonic, as shown in test_soft_bundle_different_gas_payers.

pub async fn execute_signed_txns_in_soft_bundle( &self, signed_txs: &[Transaction], ) -> SuiResult<Vec<(TransactionDigest, TransactionEffects)>>

pub async fn execute_soft_bundle_with_conflicts( &self, signed_txs: &[Transaction], ) -> SuiResult<Vec<(TransactionDigest, WaitForEffectsResponse)>>

Execute signed transactions in a soft bundle and return results for each transaction. Unlike execute_signed_txns_in_soft_bundle, this method handles conflicting transactions where some may be executed and others rejected.

Returns a vector of (digest, WaitForEffectsResponse) for each transaction.

pub async fn wait_for_tx_settlement(&self, digests: &[TransactionDigest])

pub async fn wait_for_tx_settlement_all_nodes( &self, digests: &[TransactionDigest], )

Like wait_for_tx_settlement, but waits on every node (all validators and fullnodes) instead of only the rpc fullnode. Nodes can execute the same checkpoint at different times, so the rpc fullnode having settled a transaction does not imply every validator has. Use this when a subsequent step may interact with an arbitrary validator (e.g. a soft bundle is submitted to a randomly chosen validator) and that validator must have already applied the settlement of digests.

pub async fn wait_for_rpc_index_ready(&self)

Wait until the rpc fullnode’s embedded rpc-store has indexed through its current highest executed checkpoint. Call after building the cluster so genesis data is queryable through index surfaces before tests issue their first index reads. No-op when the fullnode has indexing disabled.

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

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 and events from the transaction driver. It also does not check whether the transaction is executed successfully. Before returning, it waits for the transaction to settle on the fullnode so that subsequent queries there read consistent results.

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

pub async fn submit_and_execute( &self, tx: Transaction, client_addr: Option<SocketAddr>, ) -> Result<(TransactionEffects, TransactionEvents)>

Submit a transaction through the transaction driver and wait for finality. Returns the raw transaction effects and events without checking execution status.

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