Struct TestIndexer

pub struct TestIndexer<R: RpcConnection> {
    pub state_merkle_trees: Vec<StateMerkleTreeBundle>,
    pub address_merkle_trees: Vec<AddressMerkleTreeBundle>,
    pub payer: Keypair,
    pub group_pda: Pubkey,
    pub compressed_accounts: Vec<CompressedAccountWithMerkleContext>,
    pub nullified_compressed_accounts: Vec<CompressedAccountWithMerkleContext>,
    pub token_compressed_accounts: Vec<TokenDataWithContext>,
    pub token_nullified_compressed_accounts: Vec<TokenDataWithContext>,
    pub events: Vec<PublicTransactionEvent>,
    pub proof_types: Vec<ProofType>,
    /* private fields */
}

Fields

state_merkle_trees: Vec<StateMerkleTreeBundle>

address_merkle_trees: Vec<AddressMerkleTreeBundle>

payer: Keypair

group_pda: Pubkey

compressed_accounts: Vec<CompressedAccountWithMerkleContext>

nullified_compressed_accounts: Vec<CompressedAccountWithMerkleContext>

token_compressed_accounts: Vec<TokenDataWithContext>

token_nullified_compressed_accounts: Vec<TokenDataWithContext>

events: Vec<PublicTransactionEvent>

proof_types: Vec<ProofType>

Implementations

impl<R: RpcConnection> TestIndexer<R>

pub async fn init_from_env( payer: &Keypair, env: &EnvAccounts, inclusion: bool, non_inclusion: bool, ) -> Self

pub async fn new( state_merkle_tree_accounts: Vec<StateMerkleTreeAccounts>, address_merkle_tree_accounts: Vec<AddressMerkleTreeAccounts>, payer: Keypair, group_pda: Pubkey, inclusion: bool, non_inclusion: bool, ) -> Self

pub fn add_address_merkle_tree_bundle( address_merkle_tree_accounts: AddressMerkleTreeAccounts, ) -> AddressMerkleTreeBundle

pub async fn add_address_merkle_tree( &mut self, rpc: &mut R, merkle_tree_keypair: &Keypair, queue_keypair: &Keypair, owning_program_id: Option<Pubkey>, ) -> AddressMerkleTreeAccounts

pub async fn add_state_merkle_tree( &mut self, rpc: &mut R, merkle_tree_keypair: &Keypair, nullifier_queue_keypair: &Keypair, cpi_context_keypair: &Keypair, owning_program_id: Option<Pubkey>, forester: Option<Pubkey>, )

pub fn add_lamport_compressed_accounts(&mut self, event_bytes: Vec<u8>)

deserializes an event adds the output_compressed_accounts to the compressed_accounts removes the input_compressed_accounts from the compressed_accounts adds the input_compressed_accounts to the nullified_compressed_accounts

pub fn add_compressed_accounts_with_token_data( &mut self, event: &PublicTransactionEvent, )

deserializes an event adds the output_compressed_accounts to the compressed_accounts removes the input_compressed_accounts from the compressed_accounts adds the input_compressed_accounts to the nullified_compressed_accounts deserialiazes token data from the output_compressed_accounts adds the token_compressed_accounts to the token_compressed_accounts

pub fn get_compressed_balance(&self, owner: &Pubkey) -> u64

returns the compressed sol balance of the owner pubkey

pub fn get_compressed_token_balance(&self, owner: &Pubkey, mint: &Pubkey) -> u64

returns the compressed token balance of the owner pubkey for a token by mint

Trait Implementations

impl<R: Debug + RpcConnection> Debug for TestIndexer<R>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<R: RpcConnection + Send + Sync + 'static> Indexer<R> for TestIndexer<R>

fn get_compressed_accounts_by_owner( &self, owner: &Pubkey, ) -> Vec<CompressedAccountWithMerkleContext>

returns compressed_accounts with the owner pubkey does not return token accounts.

async fn get_multiple_compressed_account_proofs( &self, hashes: Vec<String>, ) -> Result<Vec<MerkleProof>, IndexerError>

async fn get_rpc_compressed_accounts_by_owner( &self, owner: &Pubkey, ) -> Result<Vec<String>, IndexerError>

async fn get_multiple_new_address_proofs( &self, merkle_tree_pubkey: [u8; 32], addresses: Vec<[u8; 32]>, ) -> Result<Vec<NewAddressProofWithContext>, IndexerError>

fn account_nullified(&mut self, merkle_tree_pubkey: Pubkey, account_hash: &str)

fn address_tree_updated( &mut self, merkle_tree_pubkey: Pubkey, context: &NewAddressProofWithContext, )

fn get_state_merkle_tree_accounts( &self, pubkeys: &[Pubkey], ) -> Vec<StateMerkleTreeAccounts>

fn add_event_and_compressed_accounts( &mut self, event: &PublicTransactionEvent, ) -> (Vec<CompressedAccountWithMerkleContext>, Vec<TokenDataWithContext>)

fn get_state_merkle_trees(&self) -> &Vec<StateMerkleTreeBundle>

fn get_state_merkle_trees_mut(&mut self) -> &mut Vec<StateMerkleTreeBundle>

fn get_address_merkle_trees(&self) -> &Vec<AddressMerkleTreeBundle>

fn get_address_merkle_trees_mut(&mut self) -> &mut Vec<AddressMerkleTreeBundle>

fn get_token_compressed_accounts(&self) -> &Vec<TokenDataWithContext>

fn get_payer(&self) -> &Keypair

fn get_group_pda(&self) -> &Pubkey

async fn create_proof_for_compressed_accounts( &mut self, compressed_accounts: Option<&[[u8; 32]]>, state_merkle_tree_pubkeys: Option<&[Pubkey]>, new_addresses: Option<&[[u8; 32]]>, address_merkle_tree_pubkeys: Option<Vec<Pubkey>>, rpc: &mut R, ) -> ProofRpcResult

fn add_address_merkle_tree_accounts( &mut self, merkle_tree_keypair: &Keypair, queue_keypair: &Keypair, _owning_program_id: Option<Pubkey>, ) -> AddressMerkleTreeAccounts

fn get_compressed_token_accounts_by_owner( &self, owner: &Pubkey, ) -> Vec<TokenDataWithContext>

fn add_state_bundle(&mut self, state_bundle: StateMerkleTreeBundle)