Struct TestEnv 

pub struct TestEnv {
    pub cluster: TestCluster,
    pub rgp: u64,
    pub chain_id: ChainIdentifier,
    pub gas_objects: BTreeMap<SuiAddress, Vec<ObjectRef>>,
    /* private fields */
}

Fields

cluster: TestCluster

rgp: u64

chain_id: ChainIdentifier

gas_objects: BTreeMap<SuiAddress, Vec<ObjectRef>>

Implementations

impl TestEnv

pub async fn update_all_gas(&mut self)

pub async fn fund_one_address_balance( &mut self, address: SuiAddress, amount: u64, )

pub async fn fund_all_address_balances(&mut self, amount: u64)

pub fn get_sender(&self, index: usize) -> SuiAddress

pub fn get_sender_and_gas(&self, index: usize) -> (SuiAddress, ObjectRef)

pub fn get_sender_and_all_gas( &self, index: usize, ) -> (SuiAddress, Vec<ObjectRef>)

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

pub fn get_gas_for_sender(&self, sender: SuiAddress) -> Vec<ObjectRef>

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

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

pub fn tx_builder_with_gas_objects( &self, sender: SuiAddress, gas_objects: Vec<ObjectRef>, ) -> TestTransactionBuilder

pub async fn exec_tx_directly( &mut self, tx: TransactionData, ) -> SuiResult<(TransactionDigest, TransactionEffects)>

pub async fn setup_test_package(&mut self, path: impl AsRef<Path>) -> ObjectID

pub async fn setup_custom_coin(&mut self) -> (SuiAddress, TypeTag)

pub async fn setup_mintable_coin( &mut self, ) -> (SuiAddress, ObjectID, TypeTag, ObjectRef)

Publish the coins package and return (publisher, package_id, coin_type, treasury_cap_ref). The MINTABLE_COIN TreasuryCap is unfrozen so new Coin objects can be minted.

pub async fn mint_coin( &mut self, publisher: SuiAddress, package_id: ObjectID, treasury_cap_ref: ObjectRef, amount: u64, recipient: SuiAddress, ) -> (ObjectRef, ObjectRef)

Mint a Coin<T> of the given amount to the recipient using the TreasuryCap. Returns the updated TreasuryCap ref and the new Coin object ref.

pub fn encode_coin_reservation( &self, sender: SuiAddress, epoch: u64, amount: u64, ) -> ObjectRef

pub fn encode_coin_reservation_for_type( &self, sender: SuiAddress, epoch: u64, amount: u64, coin_type: TypeTag, ) -> ObjectRef

pub async fn transfer_from_coin_to_address_balance( &mut self, sender: SuiAddress, coin: ObjectRef, amounts_and_recipients: Vec<(u64, SuiAddress)>, ) -> SuiResult<(TransactionDigest, TransactionEffects)>

Transfer a portion of a coin to one or more addresses.

pub async fn transfer_coin_to_address_balance( &mut self, sender: SuiAddress, coin: ObjectRef, recipient: SuiAddress, ) -> SuiResult<(TransactionDigest, TransactionEffects)>

Transfer the entire coin to a single address.

pub fn verify_accumulator_exists( &self, owner: SuiAddress, expected_balance: u64, )

pub fn verify_accumulator_object_count(&self, expected_object_count: u64)

Verify the accumulator object count after settlement.

pub fn get_sui_balance_ab(&self, owner: SuiAddress) -> u64

Get the balance of the owner’s SUI address balance.

pub async fn get_coin_balance(&self, object_id: ObjectID) -> u64

pub fn get_balance_ab(&self, owner: SuiAddress, coin_type: TypeTag) -> u64

Get the balance of the owner’s address balance for a given coin type.

pub async fn get_sui_balance(&self, owner: SuiAddress) -> u64

Get the total balance of SUI owned by the address (including address balance and coins).

pub async fn get_balance_for_coin_type( &self, owner: SuiAddress, coin_type: TypeTag, ) -> u64

Get the total balance of a given coin type owned by the address (including address balance and coins).

pub fn verify_accumulator_removed(&self, owner: SuiAddress)

pub async fn trigger_reconfiguration(&self)

pub fn create_gasless_transaction( &self, amount: u64, token_type: TypeTag, sender: SuiAddress, recipient: SuiAddress, nonce: u32, epoch: u64, ) -> TransactionData

pub fn gasless_transaction_data( &self, tx_kind: TransactionKind, sender: SuiAddress, nonce: u32, epoch: u64, ) -> TransactionData

pub async fn setup_funded_object_balance_vault( &mut self, amount: u64, ) -> (ObjectID, ObjectID)

Publishes the object_balance example package, creates an owned vault object, and funds it with the given amount. Returns (package_id, vault_id).

pub async fn publish_trusted_coin( &mut self, sender: SuiAddress, ) -> (ObjectID, TypeTag, ObjectRef)

Publish the trusted_coin package and return (package_id, coin_type, treasury_cap).

pub async fn mint_trusted_coin( &mut self, sender: SuiAddress, package_id: ObjectID, treasury_cap: ObjectRef, amount: u64, ) -> (ObjectRef, ObjectRef)

Mint a trusted coin. Returns (coin_ref, updated_treasury_cap).

pub async fn transfer_coin( &mut self, sender: SuiAddress, coin: ObjectRef, recipient: SuiAddress, )

Transfer a coin to recipient.

pub async fn transfer_sui( &mut self, sender: SuiAddress, recipient: SuiAddress, amount: u64, )

Transfer SUI from sender’s gas to recipient.

pub async fn transfer_sui_to_address_balance( &mut self, sender: SuiAddress, recipient: SuiAddress, amount: u64, )

Transfer SUI from sender’s gas to recipient’s address balance.

pub async fn publish_trusted_coin_and_setup( &mut self, funder: SuiAddress, recipient: SuiAddress, config: &CoinTypeConfig, coin_amount: u64, ) -> (ObjectID, TypeTag)

Convenience: publish trusted_coin and set up coins for recipient per config.

pub async fn publish_and_mint_trusted_coin( &mut self, sender: SuiAddress, amount: u64, ) -> (ObjectID, TypeTag)

Legacy: publish trusted_coin with one real coin and address balance for sender.