Trait Rpc 

pub trait Rpc:
    Send
    + Sync
    + Debug
    + 'static {
    // Required methods
    fn new<'async_trait>(
        config: LightClientConfig,
    ) -> Pin<Box<dyn Future<Output = Result<Self, RpcError>> + Send + 'async_trait>>
       where Self: Sized + 'async_trait;
    fn get_payer(&self) -> &Keypair;
    fn get_url(&self) -> String;
    fn health<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<(), RpcError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn get_program_accounts<'life0, 'life1, 'async_trait>(
        &'life0 self,
        program_id: &'life1 Pubkey,
    ) -> Pin<Box<dyn Future<Output = Result<Vec<(Pubkey, Account)>, RpcError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn get_program_accounts_with_discriminator<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        program_id: &'life1 Pubkey,
        discriminator: &'life2 [u8],
    ) -> Pin<Box<dyn Future<Output = Result<Vec<(Pubkey, Account)>, RpcError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn confirm_transaction<'life0, 'async_trait>(
        &'life0 self,
        signature: Signature,
    ) -> Pin<Box<dyn Future<Output = Result<bool, RpcError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn get_account<'life0, 'async_trait>(
        &'life0 self,
        address: Pubkey,
    ) -> Pin<Box<dyn Future<Output = Result<Option<Account>, RpcError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn get_multiple_accounts<'life0, 'life1, 'async_trait>(
        &'life0 self,
        addresses: &'life1 [Pubkey],
    ) -> Pin<Box<dyn Future<Output = Result<Vec<Option<Account>>, RpcError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn get_minimum_balance_for_rent_exemption<'life0, 'async_trait>(
        &'life0 self,
        data_len: usize,
    ) -> Pin<Box<dyn Future<Output = Result<u64, RpcError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn airdrop_lamports<'life0, 'life1, 'async_trait>(
        &'life0 mut self,
        to: &'life1 Pubkey,
        lamports: u64,
    ) -> Pin<Box<dyn Future<Output = Result<Signature, RpcError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn get_balance<'life0, 'life1, 'async_trait>(
        &'life0 self,
        pubkey: &'life1 Pubkey,
    ) -> Pin<Box<dyn Future<Output = Result<u64, RpcError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn get_latest_blockhash<'life0, 'async_trait>(
        &'life0 mut self,
    ) -> Pin<Box<dyn Future<Output = Result<(Hash, u64), RpcError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn get_block_height<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<u64, RpcError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn get_slot<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<u64, RpcError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn get_transaction_slot<'life0, 'life1, 'async_trait>(
        &'life0 self,
        signature: &'life1 Signature,
    ) -> Pin<Box<dyn Future<Output = Result<u64, RpcError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn get_signature_statuses<'life0, 'life1, 'async_trait>(
        &'life0 self,
        signatures: &'life1 [Signature],
    ) -> Pin<Box<dyn Future<Output = Result<Vec<Option<TransactionStatus>>, RpcError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn send_transaction<'life0, 'life1, 'async_trait>(
        &'life0 self,
        transaction: &'life1 Transaction,
    ) -> Pin<Box<dyn Future<Output = Result<Signature, RpcError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn send_transaction_with_config<'life0, 'life1, 'async_trait>(
        &'life0 self,
        transaction: &'life1 Transaction,
        config: RpcSendTransactionConfig,
    ) -> Pin<Box<dyn Future<Output = Result<Signature, RpcError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn send_versioned_transaction_with_config<'life0, 'life1, 'async_trait>(
        &'life0 self,
        transaction: &'life1 VersionedTransaction,
        config: RpcSendTransactionConfig,
    ) -> Pin<Box<dyn Future<Output = Result<Signature, RpcError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn process_transaction<'life0, 'async_trait>(
        &'life0 mut self,
        transaction: Transaction,
    ) -> Pin<Box<dyn Future<Output = Result<Signature, RpcError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn process_versioned_transaction<'life0, 'async_trait>(
        &'life0 mut self,
        transaction: VersionedTransaction,
    ) -> Pin<Box<dyn Future<Output = Result<Signature, RpcError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn process_transaction_with_context<'life0, 'async_trait>(
        &'life0 mut self,
        transaction: Transaction,
    ) -> Pin<Box<dyn Future<Output = Result<(Signature, Slot), RpcError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn create_and_send_transaction_with_event<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait, T>(
        &'life0 mut self,
        instructions: &'life1 [Instruction],
        authority: &'life2 Pubkey,
        signers: &'life3 [&'life4 Keypair],
    ) -> Pin<Box<dyn Future<Output = Result<Option<(T, Signature, Slot)>, RpcError>> + Send + 'async_trait>>
       where T: BorshDeserialize + Send + Debug + 'async_trait,
             Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait,
             'life3: 'async_trait,
             'life4: 'async_trait;
    fn create_and_send_versioned_transaction<'a, 'async_trait>(
        &'a mut self,
        instructions: &'a [Instruction],
        payer: &'a Pubkey,
        signers: &'a [&'a Keypair],
        address_lookup_tables: &'a [AddressLookupTableAccount],
    ) -> Pin<Box<dyn Future<Output = Result<Signature, RpcError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'a: 'async_trait;
    fn create_and_send_v1_transaction_with_event<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait, T>(
        &'life0 mut self,
        instructions: &'life1 [Instruction],
        payer: &'life2 Pubkey,
        signers: &'life3 [&'life4 Keypair],
        config: TransactionConfig,
    ) -> Pin<Box<dyn Future<Output = Result<Option<(T, Signature, Slot)>, RpcError>> + Send + 'async_trait>>
       where T: BorshDeserialize + Send + Debug + 'async_trait,
             Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait,
             'life3: 'async_trait,
             'life4: 'async_trait;
    fn create_and_send_v1_transaction_with_batched_event<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>(
        &'life0 mut self,
        instructions: &'life1 [Instruction],
        payer: &'life2 Pubkey,
        signers: &'life3 [&'life4 Keypair],
        config: TransactionConfig,
    ) -> Pin<Box<dyn Future<Output = Result<Option<(Vec<BatchPublicTransactionEvent>, Signature, Slot)>, RpcError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait,
             'life3: 'async_trait,
             'life4: 'async_trait;
    fn create_and_send_transaction_with_public_event<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>(
        &'life0 mut self,
        instruction: &'life1 [Instruction],
        payer: &'life2 Pubkey,
        signers: &'life3 [&'life4 Keypair],
    ) -> Pin<Box<dyn Future<Output = Result<Option<(PublicTransactionEvent, Signature, Slot)>, RpcError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait,
             'life3: 'async_trait,
             'life4: 'async_trait;
    fn create_and_send_transaction_with_batched_event<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>(
        &'life0 mut self,
        instruction: &'life1 [Instruction],
        payer: &'life2 Pubkey,
        signers: &'life3 [&'life4 Keypair],
    ) -> Pin<Box<dyn Future<Output = Result<Option<(Vec<BatchPublicTransactionEvent>, Signature, Slot)>, RpcError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait,
             'life3: 'async_trait,
             'life4: 'async_trait;
    fn indexer(&self) -> Result<&impl Indexer, RpcError>;
    fn indexer_mut(&mut self) -> Result<&mut impl Indexer, RpcError>;
    fn get_latest_active_state_trees<'life0, 'async_trait>(
        &'life0 mut self,
    ) -> Pin<Box<dyn Future<Output = Result<Vec<TreeInfo>, RpcError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn get_state_tree_infos(&self) -> Vec<TreeInfo>;
    fn get_random_state_tree_info(&self) -> Result<TreeInfo, RpcError>;
    fn get_random_state_tree_info_v1(&self) -> Result<TreeInfo, RpcError>;
    fn get_address_tree_v1(&self) -> TreeInfo;
    fn get_address_tree_v2(&self) -> TreeInfo;

    // Provided methods
    fn should_retry(&self, error: &RpcError) -> bool { ... }
    fn get_anchor_account<'life0, 'life1, 'async_trait, T>(
        &'life0 self,
        pubkey: &'life1 Pubkey,
    ) -> Pin<Box<dyn Future<Output = Result<Option<T>, RpcError>> + Send + 'async_trait>>
       where T: 'async_trait + BorshDeserialize,
             Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait { ... }
    fn process_versioned_transaction_with_context<'life0, 'async_trait>(
        &'life0 mut self,
        transaction: VersionedTransaction,
    ) -> Pin<Box<dyn Future<Output = Result<(Signature, Slot), RpcError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait { ... }
    fn create_and_send_transaction<'a, 'async_trait>(
        &'a mut self,
        instructions: &'a [Instruction],
        payer: &'a Pubkey,
        signers: &'a [&'a Keypair],
    ) -> Pin<Box<dyn Future<Output = Result<Signature, RpcError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'a: 'async_trait { ... }
    fn create_and_send_v1_transaction<'a, 'async_trait>(
        &'a mut self,
        instructions: &'a [Instruction],
        payer: &'a Pubkey,
        signers: &'a [&'a Keypair],
        config: TransactionConfig,
    ) -> Pin<Box<dyn Future<Output = Result<Signature, RpcError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'a: 'async_trait { ... }
}

Required Methods

fn new<'async_trait>( config: LightClientConfig, ) -> Pin<Box<dyn Future<Output = Result<Self, RpcError>> + Send + 'async_trait>>

where Self: Sized + 'async_trait,

fn get_payer(&self) -> &Keypair

fn get_url(&self) -> String

fn health<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<(), RpcError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn get_program_accounts<'life0, 'life1, 'async_trait>( &'life0 self, program_id: &'life1 Pubkey, ) -> Pin<Box<dyn Future<Output = Result<Vec<(Pubkey, Account)>, RpcError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn get_program_accounts_with_discriminator<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, program_id: &'life1 Pubkey, discriminator: &'life2 [u8], ) -> Pin<Box<dyn Future<Output = Result<Vec<(Pubkey, Account)>, RpcError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

fn confirm_transaction<'life0, 'async_trait>( &'life0 self, signature: Signature, ) -> Pin<Box<dyn Future<Output = Result<bool, RpcError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn get_account<'life0, 'async_trait>( &'life0 self, address: Pubkey, ) -> Pin<Box<dyn Future<Output = Result<Option<Account>, RpcError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Returns an account struct.

fn get_multiple_accounts<'life0, 'life1, 'async_trait>( &'life0 self, addresses: &'life1 [Pubkey], ) -> Pin<Box<dyn Future<Output = Result<Vec<Option<Account>>, RpcError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Returns multiple account structs.

fn get_minimum_balance_for_rent_exemption<'life0, 'async_trait>( &'life0 self, data_len: usize, ) -> Pin<Box<dyn Future<Output = Result<u64, RpcError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn airdrop_lamports<'life0, 'life1, 'async_trait>( &'life0 mut self, to: &'life1 Pubkey, lamports: u64, ) -> Pin<Box<dyn Future<Output = Result<Signature, RpcError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn get_balance<'life0, 'life1, 'async_trait>( &'life0 self, pubkey: &'life1 Pubkey, ) -> Pin<Box<dyn Future<Output = Result<u64, RpcError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn get_latest_blockhash<'life0, 'async_trait>( &'life0 mut self, ) -> Pin<Box<dyn Future<Output = Result<(Hash, u64), RpcError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn get_block_height<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<u64, RpcError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn get_slot<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<u64, RpcError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn get_transaction_slot<'life0, 'life1, 'async_trait>( &'life0 self, signature: &'life1 Signature, ) -> Pin<Box<dyn Future<Output = Result<u64, RpcError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn get_signature_statuses<'life0, 'life1, 'async_trait>( &'life0 self, signatures: &'life1 [Signature], ) -> Pin<Box<dyn Future<Output = Result<Vec<Option<TransactionStatus>>, RpcError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn send_transaction<'life0, 'life1, 'async_trait>( &'life0 self, transaction: &'life1 Transaction, ) -> Pin<Box<dyn Future<Output = Result<Signature, RpcError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn send_transaction_with_config<'life0, 'life1, 'async_trait>( &'life0 self, transaction: &'life1 Transaction, config: RpcSendTransactionConfig, ) -> Pin<Box<dyn Future<Output = Result<Signature, RpcError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn send_versioned_transaction_with_config<'life0, 'life1, 'async_trait>( &'life0 self, transaction: &'life1 VersionedTransaction, config: RpcSendTransactionConfig, ) -> Pin<Box<dyn Future<Output = Result<Signature, RpcError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn process_transaction<'life0, 'async_trait>( &'life0 mut self, transaction: Transaction, ) -> Pin<Box<dyn Future<Output = Result<Signature, RpcError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn process_versioned_transaction<'life0, 'async_trait>( &'life0 mut self, transaction: VersionedTransaction, ) -> Pin<Box<dyn Future<Output = Result<Signature, RpcError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn process_transaction_with_context<'life0, 'async_trait>( &'life0 mut self, transaction: Transaction, ) -> Pin<Box<dyn Future<Output = Result<(Signature, Slot), RpcError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn create_and_send_transaction_with_event<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait, T>( &'life0 mut self, instructions: &'life1 [Instruction], authority: &'life2 Pubkey, signers: &'life3 [&'life4 Keypair], ) -> Pin<Box<dyn Future<Output = Result<Option<(T, Signature, Slot)>, RpcError>> + Send + 'async_trait>>

where T: BorshDeserialize + Send + Debug + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait,

fn create_and_send_versioned_transaction<'a, 'async_trait>( &'a mut self, instructions: &'a [Instruction], payer: &'a Pubkey, signers: &'a [&'a Keypair], address_lookup_tables: &'a [AddressLookupTableAccount], ) -> Pin<Box<dyn Future<Output = Result<Signature, RpcError>> + Send + 'async_trait>>

where Self: 'async_trait, 'a: 'async_trait,

fn create_and_send_v1_transaction_with_event<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait, T>( &'life0 mut self, instructions: &'life1 [Instruction], payer: &'life2 Pubkey, signers: &'life3 [&'life4 Keypair], config: TransactionConfig, ) -> Pin<Box<dyn Future<Output = Result<Option<(T, Signature, Slot)>, RpcError>> + Send + 'async_trait>>

where T: BorshDeserialize + Send + Debug + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait,

Transaction v1 counterpart of create_and_send_transaction_with_event. See Rpc::create_and_send_v1_transaction for the v1 rules.

fn create_and_send_v1_transaction_with_batched_event<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 mut self, instructions: &'life1 [Instruction], payer: &'life2 Pubkey, signers: &'life3 [&'life4 Keypair], config: TransactionConfig, ) -> Pin<Box<dyn Future<Output = Result<Option<(Vec<BatchPublicTransactionEvent>, Signature, Slot)>, RpcError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait,

Transaction v1 counterpart of create_and_send_transaction_with_batched_event. See Rpc::create_and_send_v1_transaction for the v1 rules.

fn create_and_send_transaction_with_public_event<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 mut self, instruction: &'life1 [Instruction], payer: &'life2 Pubkey, signers: &'life3 [&'life4 Keypair], ) -> Pin<Box<dyn Future<Output = Result<Option<(PublicTransactionEvent, Signature, Slot)>, RpcError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait,

fn create_and_send_transaction_with_batched_event<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 mut self, instruction: &'life1 [Instruction], payer: &'life2 Pubkey, signers: &'life3 [&'life4 Keypair], ) -> Pin<Box<dyn Future<Output = Result<Option<(Vec<BatchPublicTransactionEvent>, Signature, Slot)>, RpcError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait,

fn indexer(&self) -> Result<&impl Indexer, RpcError>

fn indexer_mut(&mut self) -> Result<&mut impl Indexer, RpcError>

fn get_latest_active_state_trees<'life0, 'async_trait>( &'life0 mut self, ) -> Pin<Box<dyn Future<Output = Result<Vec<TreeInfo>, RpcError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Fetch the latest state tree addresses from the cluster.

fn get_state_tree_infos(&self) -> Vec<TreeInfo>

Gets state tree infos. State trees are cached and have to be fetched or set.

fn get_random_state_tree_info(&self) -> Result<TreeInfo, RpcError>

Gets a random state tree info. State trees are cached and have to be fetched or set. Returns v1 state trees by default, v2 state trees when v2 feature is enabled.

fn get_random_state_tree_info_v1(&self) -> Result<TreeInfo, RpcError>

Gets a random v1 state tree info. State trees are cached and have to be fetched or set.

fn get_address_tree_v1(&self) -> TreeInfo

fn get_address_tree_v2(&self) -> TreeInfo

Provided Methods

fn should_retry(&self, error: &RpcError) -> bool

fn get_anchor_account<'life0, 'life1, 'async_trait, T>( &'life0 self, pubkey: &'life1 Pubkey, ) -> Pin<Box<dyn Future<Output = Result<Option<T>, RpcError>> + Send + 'async_trait>>

where T: 'async_trait + BorshDeserialize, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Returns an a borsh deserialized account. Deserialization skips the discriminator.

fn process_versioned_transaction_with_context<'life0, 'async_trait>( &'life0 mut self, transaction: VersionedTransaction, ) -> Pin<Box<dyn Future<Output = Result<(Signature, Slot), RpcError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Sends and confirms a versioned transaction, returning the signature and the slot it landed in.

fn create_and_send_transaction<'a, 'async_trait>( &'a mut self, instructions: &'a [Instruction], payer: &'a Pubkey, signers: &'a [&'a Keypair], ) -> Pin<Box<dyn Future<Output = Result<Signature, RpcError>> + Send + 'async_trait>>

where Self: 'async_trait, 'a: 'async_trait,

fn create_and_send_v1_transaction<'a, 'async_trait>( &'a mut self, instructions: &'a [Instruction], payer: &'a Pubkey, signers: &'a [&'a Keypair], config: TransactionConfig, ) -> Pin<Box<dyn Future<Output = Result<Signature, RpcError>> + Send + 'async_trait>>

where Self: 'async_trait, 'a: 'async_trait,

Creates, signs and sends a transaction v1 (SIMD-0385).

A v1 transaction may be up to 4,096 bytes. It has no address lookup tables, and its compute budget comes from config instead of ComputeBudget instructions: do not include those in instructions. When config.compute_unit_limit is None the client applies crate::rpc::DEFAULT_COMPUTE_UNIT_LIMIT. config.priority_fee is a total in lamports.

The cluster rejects v1 transactions until the enable_tx_v1 feature gate is active.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors

impl Rpc for LightClient