Struct E2ETestEnv

pub struct E2ETestEnv<R: RpcConnection, I: Indexer<R>> {

    pub payer: Keypair,
    pub governance_keypair: Keypair,
    pub indexer: I,
    pub users: Vec<User>,
    pub mints: Vec<Pubkey>,
    pub foresters: Vec<TestForester>,
    pub rpc: R,
    pub keypair_action_config: KeypairActionConfig,
    pub general_action_config: GeneralActionConfig,
    pub round: u64,
    pub rounds: u64,
    pub rng: StdRng,
    pub stats: Stats,
    pub epoch: u64,
    pub slot: u64,
    pub epoch_config: Forester,
    pub protocol_config: ProtocolConfig,
    pub registration_epoch: u64,
}

Fields

payer: Keypair

governance_keypair: Keypair

indexer: I

users: Vec<User>

mints: Vec<Pubkey>

foresters: Vec<TestForester>

rpc: R

keypair_action_config: KeypairActionConfig

general_action_config: GeneralActionConfig

round: u64

rounds: u64

rng: StdRng

stats: Stats

epoch: u64

slot: u64

epoch_config: Forester

Forester struct is reused but not used for foresting here Epoch config keeps track of the ongong epochs.

protocol_config: ProtocolConfig

registration_epoch: u64

Implementations

impl<R, I> E2ETestEnv<R, I>

where R: RpcConnection, I: Indexer<R>,

pub async fn new( rpc: R, indexer: I, env_accounts: &EnvAccounts, keypair_action_config: KeypairActionConfig, general_action_config: GeneralActionConfig, rounds: u64, seed: Option<u64>, ) -> Self

pub async fn create_user(rng: &mut StdRng, rpc: &mut R) -> User

Creates a new user with a random keypair and 100 sol

pub async fn get_balance(&mut self, pubkey: &Pubkey) -> u64

pub async fn execute_rounds(&mut self)

pub async fn execute_round(&mut self)

pub async fn activate_general_actions(&mut self)

1. Add a new keypair
2. Create a new state Merkle tree

pub async fn create_state_tree(&mut self, rollover_threshold: Option<u64>)

pub async fn create_address_tree(&mut self, rollover_threshold: Option<u64>)

pub fn safe_gen_range<T, RR>( rng: &mut StdRng, range: RR, empty_fallback: T, ) -> T

where T: SampleUniform + Copy, RR: SampleRange<T> + Sized,

pub async fn activate_keypair_actions(&mut self, user: &Pubkey)

1. Transfer spl tokens between random users

pub fn get_eligible_forester_for_queue( queue_pubkey: &Pubkey, foresters: &[TestForester], light_slot: u64, ) -> Option<Keypair>

pub async fn transfer_sol_deterministic( &mut self, from: &Keypair, to: &Pubkey, tree_index: Option<usize>, ) -> Result<Signature, RpcError>

pub async fn transfer_sol(&mut self, user_index: usize)

pub async fn decompress_sol(&mut self, user_index: usize)

pub async fn compress_sol_deterministic( &mut self, from: &Keypair, amount: u64, tree_index: Option<usize>, )

pub async fn compress_sol(&mut self, user_index: usize, balance: u64)

pub async fn create_address( &mut self, optional_addresses: Option<Vec<Pubkey>>, address_tree_index: Option<usize>, ) -> Vec<Pubkey>

pub async fn transfer_spl(&mut self, user_index: usize)

pub async fn approve_spl(&mut self, user_index: usize)

pub async fn revoke_spl(&mut self, user_index: usize)

pub async fn burn_spl(&mut self, user_index: usize)

pub async fn freeze_spl(&mut self, user_index: usize)

pub async fn thaw_spl(&mut self, user_index: usize)

pub async fn compress_spl(&mut self, user_index: usize)

pub async fn decompress_spl(&mut self, user_index: usize)

pub async fn rollover_state_merkle_tree_and_queue( &mut self, index: usize, payer: &Keypair, epoch: u64, ) -> Result<(), RpcError>

pub async fn rollover_address_merkle_tree_and_queue( &mut self, index: usize, payer: &Keypair, epoch: u64, ) -> Result<(), RpcError>

pub fn get_random_compressed_sol_accounts( &mut self, user_index: usize, ) -> Vec<CompressedAccountWithMerkleContext>

pub fn get_compressed_sol_accounts( &self, pubkey: &Pubkey, ) -> Vec<CompressedAccountWithMerkleContext>

pub fn get_merkle_tree_pubkeys(&mut self, num: u64) -> Vec<Pubkey>

pub fn get_address_merkle_tree_pubkeys( &mut self, num: u64, ) -> (Vec<Pubkey>, Vec<Pubkey>)

pub async fn select_random_compressed_token_accounts( &mut self, user: &Pubkey, ) -> (Pubkey, Vec<TokenDataWithContext>)

pub async fn select_random_compressed_token_accounts_frozen( &mut self, user: &Pubkey, ) -> (Pubkey, Vec<TokenDataWithContext>)

pub async fn select_random_compressed_token_accounts_delegated( &mut self, user: &Pubkey, delegated: bool, delegate: Option<Pubkey>, frozen: bool, ) -> (Pubkey, Vec<TokenDataWithContext>)