Async Client

`spl.token.async_client`

Async SPL Token program client.

`AsyncToken`

An ERC20-like Token.

Source code in spl/token/async_client.py

class AsyncToken(_TokenCore):  # pylint: disable=too-many-public-methods
    """An ERC20-like Token."""

    def __init__(self, conn: AsyncClient, pubkey: Pubkey, program_id: Pubkey, payer: Keypair) -> None:
        """Initialize a client to a SPL-Token program."""
        super().__init__(pubkey, program_id, payer)
        self._conn = conn

    @staticmethod
    async def get_min_balance_rent_for_exempt_for_account(conn: AsyncClient) -> int:
        """Get the minimum balance for the account to be rent exempt.

        Args:
            conn: RPC connection to a solana cluster.

        Returns:
            Number of lamports required.
        """
        resp = await conn.get_minimum_balance_for_rent_exemption(ACCOUNT_LAYOUT.sizeof())
        return resp.value

    @staticmethod
    async def get_min_balance_rent_for_exempt_for_mint(conn: AsyncClient) -> int:
        """Get the minimum balance for the mint to be rent exempt.

        Args:
            conn: RPC connection to a solana cluster.

        Returns:
            Number of lamports required.
        """
        resp = await conn.get_minimum_balance_for_rent_exemption(MINT_LAYOUT.sizeof())
        return resp.value

    @staticmethod
    async def get_min_balance_rent_for_exempt_for_multisig(conn: AsyncClient) -> int:
        """Get the minimum balance for the multisig to be rent exempt.

        Args:
            conn: RPC connection to a solana cluster.

        Returns:
             Number of lamports required.
        """
        resp = await conn.get_minimum_balance_for_rent_exemption(MULTISIG_LAYOUT.sizeof())
        return resp.value

    async def get_accounts_by_owner(
        self,
        owner: Pubkey,
        commitment: Optional[Commitment] = None,
        encoding: str = "base64",
    ) -> GetTokenAccountsByOwnerResp:
        """Get token accounts of the provided owner.

        Args:
            owner: Public Key of the token account owner.
            commitment: (optional) Bank state to query.
            encoding: (optional) Encoding for Account data, either "base58" (slow) or "base64".
        """
        args = self._get_accounts_args(
            owner,
            commitment,
            encoding,
            self._conn.commitment,  # pylint: disable=protected-access
        )
        return await self._conn.get_token_accounts_by_owner(*args)

    async def get_accounts_by_owner_json_parsed(
        self,
        owner: Pubkey,
        commitment: Optional[Commitment] = None,
    ) -> GetTokenAccountsByOwnerJsonParsedResp:
        """Get token accounts of the provided owner by the token's mint, in JSON format.

        Args:
            owner: Public Key of the token account owner.
            commitment: (optional) Bank state to query.


        Parsed-JSON encoding attempts to use program-specific state parsers to return more
        human-readable and explicit account state data. If parsed-JSON is requested but a
        valid mint cannot be found for a particular account, that account will be filtered out
        from results. jsonParsed encoding is UNSTABLE.
        """
        args = self._get_accounts_args(
            owner,
            commitment,
            "jsonParsed",
            self._conn.commitment,  # pylint: disable=protected-access
        )
        return await self._conn.get_token_accounts_by_owner_json_parsed(*args)

    async def get_accounts_by_delegate(
        self,
        owner: Pubkey,
        commitment: Optional[Commitment] = None,
        encoding: str = "base64",
    ) -> GetTokenAccountsByDelegateResp:
        """Get token accounts of the provided delegate.

        Args:
            owner: Public Key of the delegate account.
            commitment: (optional) Bank state to query.
            encoding: (optional) Encoding for Account data, either "base58" (slow) or "base64".
        """
        args = self._get_accounts_args(
            owner,
            commitment,
            encoding,
            self._conn.commitment,  # pylint: disable=protected-access
        )
        return await self._conn.get_token_accounts_by_delegate(*args)

    async def get_accounts_by_delegate_json_parsed(
        self,
        owner: Pubkey,
        commitment: Optional[Commitment] = None,
        encoding: str = "base64",
    ) -> GetTokenAccountsByDelegateJsonParsedResp:
        """Get token accounts of the provided delegate, in JSON format.

        Args:
            owner: Public Key of the delegate account.
            commitment: (optional) Bank state to query.
            encoding: (optional) Encoding for Account data, either "base58" (slow) or "base64".

        Parsed-JSON encoding attempts to use program-specific state parsers to return more
        human-readable and explicit account state data. If parsed-JSON is requested but a
        valid mint cannot be found for a particular account, that account will be filtered out
        from results. jsonParsed encoding is UNSTABLE.
        """
        args = self._get_accounts_args(
            owner,
            commitment,
            encoding,
            self._conn.commitment,  # pylint: disable=protected-access
        )
        return await self._conn.get_token_accounts_by_delegate_json_parsed(*args)

    async def get_balance(self, pubkey: Pubkey, commitment: Optional[Commitment] = None) -> GetTokenAccountBalanceResp:
        """Get the balance of the provided token account.

        Args:
            pubkey: Public Key of the token account.
            commitment: (optional) Bank state to query.
        """
        return await self._conn.get_token_account_balance(pubkey, commitment)

    @classmethod
    async def create_mint(
        cls,
        conn: AsyncClient,
        payer: Keypair,
        mint_authority: Pubkey,
        decimals: int,
        program_id: Pubkey,
        freeze_authority: Optional[Pubkey] = None,
        skip_confirmation: bool = False,
        recent_blockhash: Optional[Blockhash] = None,
    ) -> AsyncToken:
        """Create and initialize a token.

        Args:
            conn: RPC connection to a solana cluster.
            payer: Fee payer for transaction.
            mint_authority: Account or multisig that will control minting.
            decimals: Location of the decimal place.
            program_id: SPL Token program account.
            freeze_authority: (optional) Account or multisig that can freeze token accounts.
            skip_confirmation: (optional) Option to skip transaction confirmation.
            recent_blockhash: (optional) a prefetched Blockhash for the transaction.

        Returns:
            Token object for the newly minted token.

        If skip confirmation is set to `False`, this method will block for at most 30 seconds
        or until the transaction is confirmed.
        """
        # Allocate memory for the account
        balance_needed = await AsyncToken.get_min_balance_rent_for_exempt_for_mint(conn)
        # Construct transaction
        recent_blockhash_to_use = (
            (await conn.get_latest_blockhash()).value.blockhash if recent_blockhash is None else recent_blockhash
        )
        token, txn, opts = _TokenCore._create_mint_args(
            conn,
            payer,
            mint_authority,
            decimals,
            program_id,
            freeze_authority,
            skip_confirmation,
            balance_needed,
            cls,
            conn.commitment,
            recent_blockhash_to_use,
        )
        # Send the two instructions
        await conn.send_transaction(txn, opts=opts)
        return cast(AsyncToken, token)

    async def create_account(
        self,
        owner: Pubkey,
        skip_confirmation: bool = False,
        recent_blockhash: Optional[Blockhash] = None,
    ) -> Pubkey:
        """Create and initialize a new account.

        This account may then be used as a `transfer()` or `approve()` destination.

        Args:
            owner: User account that will own the new account.
            skip_confirmation: (optional) Option to skip transaction confirmation.
            recent_blockhash (optional): A prefetched blockhash for the transaction.

        Returns:
            Public key of the new empty account.

        If skip confirmation is set to `False`, this method will block for at most 30 seconds
        or until the transaction is confirmed.
        """
        balance_needed = await AsyncToken.get_min_balance_rent_for_exempt_for_account(self._conn)
        recent_blockhash_to_use = (
            (await self._conn.get_latest_blockhash()).value.blockhash if recent_blockhash is None else recent_blockhash
        )
        new_account_pk, txn, opts = self._create_account_args(
            owner, skip_confirmation, balance_needed, self._conn.commitment, recent_blockhash_to_use
        )
        # Send the two instructions
        await self._conn.send_transaction(txn, opts=opts)
        return new_account_pk

    async def create_associated_token_account(
        self,
        owner: Pubkey,
        skip_confirmation: bool = False,
        recent_blockhash: Optional[Blockhash] = None,
    ) -> Pubkey:
        """Create an associated token account.

        Args:
            owner: User account that will own the associated token account.
            skip_confirmation: (optional) Option to skip transaction confirmation.
            recent_blockhash (optional): A prefetched blockhash for the transaction.

        Returns:
            Public key of the new associated account.

        If skip confirmation is set to `False`, this method will block for at most 30 seconds
        or until the transaction is confirmed.
        """
        # Construct transaction
        recent_blockhash_to_use = (
            (await self._conn.get_latest_blockhash()).value.blockhash if recent_blockhash is None else recent_blockhash
        )
        public_key, txn, payer, opts = self._create_associated_token_account_args(
            owner, skip_confirmation, self._conn.commitment, recent_blockhash_to_use
        )
        await self._conn.send_transaction(txn, opts=opts)
        return public_key

    @staticmethod
    async def create_wrapped_native_account(
        conn: AsyncClient,
        program_id: Pubkey,
        owner: Pubkey,
        payer: Keypair,
        amount: int,
        skip_confirmation: bool = False,
        recent_blockhash: Optional[Blockhash] = None,
    ) -> Pubkey:
        """Create and initialize a new account on the special native token mint.

        Args:
            conn: RPC connection to a solana cluster.
            program_id: SPL Token program account.
            owner: The owner of the new token account.
            payer: The source of the lamports to initialize, and payer of the initialization fees.
            amount: The amount of lamports to wrap.
            skip_confirmation: (optional) Option to skip transaction confirmation.
            recent_blockhash: (optional) a prefetched Blockhash for the transaction.

        Returns:
            The new token account.

        If skip confirmation is set to `False`, this method will block for at most 30 seconds
        or until the transaction is confirmed.
        """
        # Allocate memory for the account
        balance_needed = await AsyncToken.get_min_balance_rent_for_exempt_for_account(conn)
        recent_blockhash_to_use = (
            (await conn.get_latest_blockhash()).value.blockhash if recent_blockhash is None else recent_blockhash
        )
        (new_account_public_key, txn, payer, new_account, opts,) = _TokenCore._create_wrapped_native_account_args(
            program_id,
            owner,
            payer,
            amount,
            skip_confirmation,
            balance_needed,
            conn.commitment,
            recent_blockhash_to_use,
        )
        await conn.send_transaction(txn, opts=opts)
        return new_account_public_key

    async def create_multisig(
        self,
        m: int,
        multi_signers: List[Pubkey],
        opts: Optional[TxOpts] = None,
        recent_blockhash: Optional[Blockhash] = None,
    ) -> Pubkey:  # pylint: disable=invalid-name
        """Create and initialize a new multisig.

        Args:
            m: Number of required signatures.
            multi_signers: Full set of signers.
            opts: (optional) Transaction options.
            recent_blockhash: (optional) a prefetched Blockhash for the transaction.

        Returns:
            Public key of the new multisig account.
        """
        balance_needed = await AsyncToken.get_min_balance_rent_for_exempt_for_multisig(self._conn)
        recent_blockhash_to_use = (
            (await self._conn.get_latest_blockhash()).value.blockhash if recent_blockhash is None else recent_blockhash
        )
        txn, multisig = self._create_multisig_args(m, multi_signers, balance_needed, recent_blockhash_to_use)
        opts_to_use = TxOpts(preflight_commitment=self._conn.commitment) if opts is None else opts
        await self._conn.send_transaction(txn, opts=opts_to_use)
        return multisig.pubkey()

    async def get_mint_info(self) -> MintInfo:
        """Retrieve mint information."""
        info = await self._conn.get_account_info(self.pubkey)
        return self._create_mint_info(info)

    async def get_account_info(self, account: Pubkey, commitment: Optional[Commitment] = None) -> AccountInfo:
        """Retrieve account information."""
        info = await self._conn.get_account_info(account, commitment)
        return self._create_account_info(info)

    async def transfer(
        self,
        source: Pubkey,
        dest: Pubkey,
        owner: Union[Keypair, Pubkey],
        amount: int,
        multi_signers: Optional[List[Keypair]] = None,
        opts: Optional[TxOpts] = None,
        recent_blockhash: Optional[Blockhash] = None,
    ) -> SendTransactionResp:
        """Transfer tokens to another account.

        Args:
            source: Public key of account to transfer tokens from.
            dest: Public key of account to transfer tokens to.
            owner: Owner of the source account.
            amount: Number of tokens to transfer.
            multi_signers: (optional) Signing accounts if `owner` is a multiSig.
            opts: (optional) Transaction options.
            recent_blockhash: (optional) a prefetched Blockhash for the transaction.
        """
        opts_to_use = TxOpts(preflight_commitment=self._conn.commitment) if opts is None else opts
        recent_blockhash_to_use = (
            (await self._conn.get_latest_blockhash()).value.blockhash if recent_blockhash is None else recent_blockhash
        )
        txn, opts = self._transfer_args(
            source, dest, owner, amount, multi_signers, opts_to_use, recent_blockhash_to_use
        )
        return await self._conn.send_transaction(txn, opts=opts)

    async def approve(
        self,
        source: Pubkey,
        delegate: Pubkey,
        owner: Pubkey,
        amount: int,
        multi_signers: Optional[List[Keypair]] = None,
        opts: Optional[TxOpts] = None,
        recent_blockhash: Optional[Blockhash] = None,
    ) -> SendTransactionResp:
        """Grant a third-party permission to transfer up the specified number of tokens from an account.

        Args:
            source: Public key of the source account.
            delegate: Account authorized to perform a transfer tokens from the source account.
            owner: Owner of the source account.
            amount: Maximum number of tokens the delegate may transfer.
            multi_signers: (optional) Signing accounts if `owner` is a multiSig.
            opts: (optional) Transaction options.
            recent_blockhash: (optional) a prefetched Blockhash for the transaction.
        """
        opts_to_use = TxOpts(preflight_commitment=self._conn.commitment) if opts is None else opts
        recent_blockhash_to_use = (
            (await self._conn.get_latest_blockhash()).value.blockhash if recent_blockhash is None else recent_blockhash
        )
        txn, payer, signers, opts = self._approve_args(
            source, delegate, owner, amount, multi_signers, opts_to_use, recent_blockhash_to_use
        )
        return await self._conn.send_transaction(txn, opts=opts)

    async def revoke(
        self,
        account: Pubkey,
        owner: Pubkey,
        multi_signers: Optional[List[Keypair]] = None,
        opts: Optional[TxOpts] = None,
        recent_blockhash: Optional[Blockhash] = None,
    ) -> SendTransactionResp:
        """Revoke transfer authority for a given account.

        Args:
            account: Source account for which transfer authority is being revoked.
            owner: Owner of the source account.
            multi_signers: (optional) Signing accounts if `owner` is a multisig.
            opts: (optional) Transaction options.
            recent_blockhash: (optional) a prefetched Blockhash for the transaction.
        """
        opts_to_use = TxOpts(preflight_commitment=self._conn.commitment) if opts is None else opts
        recent_blockhash_to_use = (
            (await self._conn.get_latest_blockhash()).value.blockhash if recent_blockhash is None else recent_blockhash
        )
        txn, payer, signers, opts = self._revoke_args(
            account, owner, multi_signers, opts_to_use, recent_blockhash_to_use
        )
        return await self._conn.send_transaction(txn, opts=opts)

    async def set_authority(
        self,
        account: Pubkey,
        current_authority: Union[Keypair, Pubkey],
        authority_type: spl_token.AuthorityType,
        new_authority: Optional[Pubkey] = None,
        multi_signers: Optional[List[Keypair]] = None,
        opts: Optional[TxOpts] = None,
        recent_blockhash: Optional[Blockhash] = None,
    ) -> SendTransactionResp:
        """Assign a new authority to the account.

        Args:
            account: Public key of the token account.
            current_authority: Current authority of the account.
            authority_type: Type of authority to set.
            new_authority: (optional) New authority of the account.
            multi_signers: (optional) Signing accounts if `owner` is a multiSig.
            opts: (optional) Transaction options.
            recent_blockhash: (optional) a prefetched Blockhash for the transaction.
        """
        opts_to_use = TxOpts(preflight_commitment=self._conn.commitment) if opts is None else opts
        recent_blockhash_to_use = (
            (await self._conn.get_latest_blockhash()).value.blockhash if recent_blockhash is None else recent_blockhash
        )
        txn, payer, signers, opts = self._set_authority_args(
            account,
            current_authority,
            authority_type,
            new_authority,
            multi_signers,
            opts_to_use,
            recent_blockhash_to_use,
        )
        return await self._conn.send_transaction(txn, opts=opts)

    async def mint_to(
        self,
        dest: Pubkey,
        mint_authority: Union[Keypair, Pubkey],
        amount: int,
        multi_signers: Optional[List[Keypair]] = None,
        opts: Optional[TxOpts] = None,
        recent_blockhash: Optional[Blockhash] = None,
    ) -> SendTransactionResp:
        """Mint new tokens.

        Args:
            dest: Public key of the account to mint to.
            mint_authority: Public key of the minting authority.
            amount: Amount to mint.
            multi_signers: (optional) Signing accounts if `owner` is a multisig.
            opts: (optional) Transaction options.
            recent_blockhash: (optional) a prefetched Blockhash for the transaction.

        If skip confirmation is set to `False`, this method will block for at most 30 seconds
        or until the transaction is confirmed.
        """
        opts_to_use = TxOpts(preflight_commitment=self._conn.commitment) if opts is None else opts
        recent_blockhash_to_use = (
            (await self._conn.get_latest_blockhash()).value.blockhash if recent_blockhash is None else recent_blockhash
        )
        txn, opts = self._mint_to_args(
            dest, mint_authority, amount, multi_signers, opts_to_use, recent_blockhash_to_use
        )
        return await self._conn.send_transaction(txn, opts=opts)

    async def burn(
        self,
        account: Pubkey,
        owner: Pubkey,
        amount: int,
        multi_signers: Optional[List[Keypair]] = None,
        opts: Optional[TxOpts] = None,
        recent_blockhash: Optional[Blockhash] = None,
    ) -> SendTransactionResp:
        """Burn tokens.

        Args:
            account: Account to burn tokens from.
            owner: Owner of the account.
            amount: Amount to burn.
            multi_signers: (optional) Signing accounts if `owner` is a multiSig.
            opts: (optional) Transaction options.
            recent_blockhash: (optional) a prefetched Blockhash for the transaction.
        """
        opts_to_use = TxOpts(preflight_commitment=self._conn.commitment) if opts is None else opts
        recent_blockhash_to_use = (
            (await self._conn.get_latest_blockhash()).value.blockhash if recent_blockhash is None else recent_blockhash
        )
        txn, opts = self._burn_args(account, owner, amount, multi_signers, opts_to_use, recent_blockhash_to_use)
        return await self._conn.send_transaction(txn, opts=opts)

    async def close_account(
        self,
        account: Pubkey,
        dest: Pubkey,
        authority: Pubkey,
        multi_signers: Optional[List[Keypair]] = None,
        opts: Optional[TxOpts] = None,
        recent_blockhash: Optional[Blockhash] = None,
    ) -> SendTransactionResp:
        """Remove approval for the transfer of any remaining tokens.

        Args:
            account: Account to close.
            dest: Account to receive the remaining balance of the closed account.
            authority: Authority which is allowed to close the account.
            multi_signers: (optional) Signing accounts if `owner` is a multiSig.
            opts: (optional) Transaction options.
            recent_blockhash: (optional) a prefetched Blockhash for the transaction.
        """
        opts_to_use = TxOpts(preflight_commitment=self._conn.commitment) if opts is None else opts
        recent_blockhash_to_use = (
            (await self._conn.get_latest_blockhash()).value.blockhash if recent_blockhash is None else recent_blockhash
        )
        txn, opts = self._close_account_args(
            account, dest, authority, multi_signers, opts_to_use, recent_blockhash_to_use
        )
        return await self._conn.send_transaction(txn, opts=opts)

    async def freeze_account(
        self,
        account: Pubkey,
        authority: Pubkey,
        multi_signers: Optional[List[Keypair]] = None,
        opts: Optional[TxOpts] = None,
        recent_blockhash: Optional[Blockhash] = None,
    ) -> SendTransactionResp:
        """Freeze account.

        Args:
            account: Account to freeze.
            authority: The mint freeze authority.
            multi_signers: (optional) Signing accounts if `authority` is a multiSig.
            opts: (optional) Transaction options.
            recent_blockhash: (optional) a prefetched Blockhash for the transaction.
        """
        opts_to_use = TxOpts(preflight_commitment=self._conn.commitment) if opts is None else opts
        recent_blockhash_to_use = (
            (await self._conn.get_latest_blockhash()).value.blockhash if recent_blockhash is None else recent_blockhash
        )
        txn, opts = self._freeze_account_args(account, authority, multi_signers, opts_to_use, recent_blockhash_to_use)
        return await self._conn.send_transaction(txn, opts=opts)

    async def thaw_account(
        self,
        account: Pubkey,
        authority: Pubkey,
        multi_signers: Optional[List[Keypair]] = None,
        opts: Optional[TxOpts] = None,
        recent_blockhash: Optional[Blockhash] = None,
    ) -> SendTransactionResp:
        """Thaw account.

        Args:
            account: Account to thaw.
            authority: The mint freeze authority.
            multi_signers: (optional) Signing accounts if `authority` is a multiSig.
            opts: (optional) Transaction options.
            recent_blockhash: (optional) a prefetched Blockhash for the transaction.
        """
        opts_to_use = TxOpts(preflight_commitment=self._conn.commitment) if opts is None else opts
        recent_blockhash_to_use = (
            (await self._conn.get_latest_blockhash()).value.blockhash if recent_blockhash is None else recent_blockhash
        )
        txn, opts = self._thaw_account_args(account, authority, multi_signers, opts_to_use, recent_blockhash_to_use)
        return await self._conn.send_transaction(txn, opts=opts)

    async def transfer_checked(
        self,
        source: Pubkey,
        dest: Pubkey,
        owner: Pubkey,
        amount: int,
        decimals: int,
        multi_signers: Optional[List[Keypair]],
        opts: Optional[TxOpts] = None,
        recent_blockhash: Optional[Blockhash] = None,
    ) -> SendTransactionResp:
        """Transfer tokens to another account, asserting the token mint and decimals.

        Args:
            source: Public key of account to transfer tokens from.
            dest: Public key of account to transfer tokens to.
            owner: Owner of the source account.
            amount: Number of tokens to transfer.
            decimals: Number of decimals in transfer amount.
            multi_signers: (optional) Signing accounts if `owner` is a multiSig.
            opts: (optional) Transaction options.
            recent_blockhash: (optional) a prefetched Blockhash for the transaction.
        """
        opts_to_use = TxOpts(preflight_commitment=self._conn.commitment) if opts is None else opts
        recent_blockhash_to_use = (
            (await self._conn.get_latest_blockhash()).value.blockhash if recent_blockhash is None else recent_blockhash
        )
        txn, opts = self._transfer_checked_args(
            source, dest, owner, amount, decimals, multi_signers, opts_to_use, recent_blockhash_to_use
        )
        return await self._conn.send_transaction(txn, opts=opts)

    async def approve_checked(
        self,
        source: Pubkey,
        delegate: Pubkey,
        owner: Pubkey,
        amount: int,
        decimals: int,
        multi_signers: Optional[List[Keypair]] = None,
        opts: Optional[TxOpts] = None,
        recent_blockhash: Optional[Blockhash] = None,
    ) -> SendTransactionResp:
        """Grant a third-party permission to transfer up the specified number of tokens from an account.

        This method also asserts the token mint and decimals.

        Args:
            source: Public key of the source account.
            delegate: Account authorized to perform a transfer tokens from the source account.
            owner: Owner of the source account.
            amount: Maximum number of tokens the delegate may transfer.
            decimals: Number of decimals in approve amount.
            multi_signers: (optional) Signing accounts if `owner` is a multisig.
            opts: (optional) Transaction options.
            recent_blockhash (optional): A prefetched blockhash for the transaction.
        """
        opts_to_use = TxOpts(preflight_commitment=self._conn.commitment) if opts is None else opts
        recent_blockhash_to_use = (
            (await self._conn.get_latest_blockhash()).value.blockhash if recent_blockhash is None else recent_blockhash
        )
        txn, opts = self._approve_checked_args(
            source, delegate, owner, amount, decimals, multi_signers, opts_to_use, recent_blockhash_to_use
        )
        return await self._conn.send_transaction(txn, opts=opts)

    async def mint_to_checked(
        self,
        dest: Pubkey,
        mint_authority: Pubkey,
        amount: int,
        decimals: int,
        multi_signers: Optional[List[Keypair]] = None,
        opts: Optional[TxOpts] = None,
        recent_blockhash: Optional[Blockhash] = None,
    ) -> SendTransactionResp:
        """Mint new tokens, asserting the token mint and decimals.

        Args:
            dest: Public key of the account to mint to.
            mint_authority: Public key of the minting authority.
            amount: Amount to mint.
            decimals: Number of decimals in amount to mint.
            multi_signers: (optional) Signing accounts if `owner` is a multiSig.
            opts: (optional) Transaction options.
            recent_blockhash (optional): A prefetched blockhash for the transaction.
        """
        opts_to_use = TxOpts(preflight_commitment=self._conn.commitment) if opts is None else opts
        recent_blockhash_to_use = (
            (await self._conn.get_latest_blockhash()).value.blockhash if recent_blockhash is None else recent_blockhash
        )
        txn, opts = self._mint_to_checked_args(
            dest, mint_authority, amount, decimals, multi_signers, opts_to_use, recent_blockhash_to_use
        )
        return await self._conn.send_transaction(txn, opts=opts)

    async def burn_checked(
        self,
        account: Pubkey,
        owner: Pubkey,
        amount: int,
        decimals: int,
        multi_signers: Optional[List[Keypair]] = None,
        opts: Optional[TxOpts] = None,
        recent_blockhash: Optional[Blockhash] = None,
    ) -> SendTransactionResp:
        """Burn tokens, asserting the token mint and decimals.

        Args:
            account: Account to burn tokens from.
            owner: Owner of the account.
            amount: Amount to burn.
            decimals: Number of decimals in amount to burn.
            multi_signers: (optional) Signing accounts if `owner` is a multisig.
            opts: (optional) Transaction options.
            recent_blockhash: (optional) a prefetched Blockhash for the transaction.
        """
        opts_to_use = TxOpts(preflight_commitment=self._conn.commitment) if opts is None else opts
        recent_blockhash_to_use = (
            (await self._conn.get_latest_blockhash()).value.blockhash if recent_blockhash is None else recent_blockhash
        )
        txn, opts = self._burn_checked_args(
            account,
            owner,
            amount,
            decimals,
            multi_signers,
            opts_to_use,
            recent_blockhash_to_use,
        )
        return await self._conn.send_transaction(txn, opts=opts)

`approve(self, source, delegate, owner, amount, multi_signers=None, opts=None, recent_blockhash=None)` `async`

Grant a third-party permission to transfer up the specified number of tokens from an account.

Parameters:

Name	Type	Description	Default
`source`	`Pubkey`	Public key of the source account.	required
`delegate`	`Pubkey`	Account authorized to perform a transfer tokens from the source account.	required
`owner`	`Pubkey`	Owner of the source account.	required
`amount`	`int`	Maximum number of tokens the delegate may transfer.	required
`multi_signers`	`Optional[List[Keypair]]`	(optional) Signing accounts if `owner` is a multiSig.	`None`
`opts`	`Optional[TxOpts]`	(optional) Transaction options.	`None`
`recent_blockhash`	`Optional[Blockhash]`	(optional) a prefetched Blockhash for the transaction.	`None`

Source code in spl/token/async_client.py

async def approve(
    self,
    source: Pubkey,
    delegate: Pubkey,
    owner: Pubkey,
    amount: int,
    multi_signers: Optional[List[Keypair]] = None,
    opts: Optional[TxOpts] = None,
    recent_blockhash: Optional[Blockhash] = None,
) -> SendTransactionResp:
    """Grant a third-party permission to transfer up the specified number of tokens from an account.

    Args:
        source: Public key of the source account.
        delegate: Account authorized to perform a transfer tokens from the source account.
        owner: Owner of the source account.
        amount: Maximum number of tokens the delegate may transfer.
        multi_signers: (optional) Signing accounts if `owner` is a multiSig.
        opts: (optional) Transaction options.
        recent_blockhash: (optional) a prefetched Blockhash for the transaction.
    """
    opts_to_use = TxOpts(preflight_commitment=self._conn.commitment) if opts is None else opts
    recent_blockhash_to_use = (
        (await self._conn.get_latest_blockhash()).value.blockhash if recent_blockhash is None else recent_blockhash
    )
    txn, payer, signers, opts = self._approve_args(
        source, delegate, owner, amount, multi_signers, opts_to_use, recent_blockhash_to_use
    )
    return await self._conn.send_transaction(txn, opts=opts)

`approve_checked(self, source, delegate, owner, amount, decimals, multi_signers=None, opts=None, recent_blockhash=None)` `async`

Grant a third-party permission to transfer up the specified number of tokens from an account.

This method also asserts the token mint and decimals.

Parameters:

Name	Type	Description	Default
`source`	`Pubkey`	Public key of the source account.	required
`delegate`	`Pubkey`	Account authorized to perform a transfer tokens from the source account.	required
`owner`	`Pubkey`	Owner of the source account.	required
`amount`	`int`	Maximum number of tokens the delegate may transfer.	required
`decimals`	`int`	Number of decimals in approve amount.	required
`multi_signers`	`Optional[List[Keypair]]`	(optional) Signing accounts if `owner` is a multisig.	`None`
`opts`	`Optional[TxOpts]`	(optional) Transaction options.	`None`
`recent_blockhash`	`optional`	A prefetched blockhash for the transaction.	`None`

Source code in spl/token/async_client.py

async def approve_checked(
    self,
    source: Pubkey,
    delegate: Pubkey,
    owner: Pubkey,
    amount: int,
    decimals: int,
    multi_signers: Optional[List[Keypair]] = None,
    opts: Optional[TxOpts] = None,
    recent_blockhash: Optional[Blockhash] = None,
) -> SendTransactionResp:
    """Grant a third-party permission to transfer up the specified number of tokens from an account.

    This method also asserts the token mint and decimals.

    Args:
        source: Public key of the source account.
        delegate: Account authorized to perform a transfer tokens from the source account.
        owner: Owner of the source account.
        amount: Maximum number of tokens the delegate may transfer.
        decimals: Number of decimals in approve amount.
        multi_signers: (optional) Signing accounts if `owner` is a multisig.
        opts: (optional) Transaction options.
        recent_blockhash (optional): A prefetched blockhash for the transaction.
    """
    opts_to_use = TxOpts(preflight_commitment=self._conn.commitment) if opts is None else opts
    recent_blockhash_to_use = (
        (await self._conn.get_latest_blockhash()).value.blockhash if recent_blockhash is None else recent_blockhash
    )
    txn, opts = self._approve_checked_args(
        source, delegate, owner, amount, decimals, multi_signers, opts_to_use, recent_blockhash_to_use
    )
    return await self._conn.send_transaction(txn, opts=opts)

`burn(self, account, owner, amount, multi_signers=None, opts=None, recent_blockhash=None)` `async`

Burn tokens.

Parameters:

Name	Type	Description	Default
`account`	`Pubkey`	Account to burn tokens from.	required
`owner`	`Pubkey`	Owner of the account.	required
`amount`	`int`	Amount to burn.	required
`multi_signers`	`Optional[List[Keypair]]`	(optional) Signing accounts if `owner` is a multiSig.	`None`
`opts`	`Optional[TxOpts]`	(optional) Transaction options.	`None`
`recent_blockhash`	`Optional[Blockhash]`	(optional) a prefetched Blockhash for the transaction.	`None`

Source code in spl/token/async_client.py

async def burn(
    self,
    account: Pubkey,
    owner: Pubkey,
    amount: int,
    multi_signers: Optional[List[Keypair]] = None,
    opts: Optional[TxOpts] = None,
    recent_blockhash: Optional[Blockhash] = None,
) -> SendTransactionResp:
    """Burn tokens.

    Args:
        account: Account to burn tokens from.
        owner: Owner of the account.
        amount: Amount to burn.
        multi_signers: (optional) Signing accounts if `owner` is a multiSig.
        opts: (optional) Transaction options.
        recent_blockhash: (optional) a prefetched Blockhash for the transaction.
    """
    opts_to_use = TxOpts(preflight_commitment=self._conn.commitment) if opts is None else opts
    recent_blockhash_to_use = (
        (await self._conn.get_latest_blockhash()).value.blockhash if recent_blockhash is None else recent_blockhash
    )
    txn, opts = self._burn_args(account, owner, amount, multi_signers, opts_to_use, recent_blockhash_to_use)
    return await self._conn.send_transaction(txn, opts=opts)

`burn_checked(self, account, owner, amount, decimals, multi_signers=None, opts=None, recent_blockhash=None)` `async`

Burn tokens, asserting the token mint and decimals.

Parameters:

Name	Type	Description	Default
`account`	`Pubkey`	Account to burn tokens from.	required
`owner`	`Pubkey`	Owner of the account.	required
`amount`	`int`	Amount to burn.	required
`decimals`	`int`	Number of decimals in amount to burn.	required
`multi_signers`	`Optional[List[Keypair]]`	(optional) Signing accounts if `owner` is a multisig.	`None`
`opts`	`Optional[TxOpts]`	(optional) Transaction options.	`None`
`recent_blockhash`	`Optional[Blockhash]`	(optional) a prefetched Blockhash for the transaction.	`None`

Source code in spl/token/async_client.py

async def burn_checked(
    self,
    account: Pubkey,
    owner: Pubkey,
    amount: int,
    decimals: int,
    multi_signers: Optional[List[Keypair]] = None,
    opts: Optional[TxOpts] = None,
    recent_blockhash: Optional[Blockhash] = None,
) -> SendTransactionResp:
    """Burn tokens, asserting the token mint and decimals.

    Args:
        account: Account to burn tokens from.
        owner: Owner of the account.
        amount: Amount to burn.
        decimals: Number of decimals in amount to burn.
        multi_signers: (optional) Signing accounts if `owner` is a multisig.
        opts: (optional) Transaction options.
        recent_blockhash: (optional) a prefetched Blockhash for the transaction.
    """
    opts_to_use = TxOpts(preflight_commitment=self._conn.commitment) if opts is None else opts
    recent_blockhash_to_use = (
        (await self._conn.get_latest_blockhash()).value.blockhash if recent_blockhash is None else recent_blockhash
    )
    txn, opts = self._burn_checked_args(
        account,
        owner,
        amount,
        decimals,
        multi_signers,
        opts_to_use,
        recent_blockhash_to_use,
    )
    return await self._conn.send_transaction(txn, opts=opts)

`close_account(self, account, dest, authority, multi_signers=None, opts=None, recent_blockhash=None)` `async`

Remove approval for the transfer of any remaining tokens.

Parameters:

Name	Type	Description	Default
`account`	`Pubkey`	Account to close.	required
`dest`	`Pubkey`	Account to receive the remaining balance of the closed account.	required
`authority`	`Pubkey`	Authority which is allowed to close the account.	required
`multi_signers`	`Optional[List[Keypair]]`	(optional) Signing accounts if `owner` is a multiSig.	`None`
`opts`	`Optional[TxOpts]`	(optional) Transaction options.	`None`
`recent_blockhash`	`Optional[Blockhash]`	(optional) a prefetched Blockhash for the transaction.	`None`

Source code in spl/token/async_client.py

async def close_account(
    self,
    account: Pubkey,
    dest: Pubkey,
    authority: Pubkey,
    multi_signers: Optional[List[Keypair]] = None,
    opts: Optional[TxOpts] = None,
    recent_blockhash: Optional[Blockhash] = None,
) -> SendTransactionResp:
    """Remove approval for the transfer of any remaining tokens.

    Args:
        account: Account to close.
        dest: Account to receive the remaining balance of the closed account.
        authority: Authority which is allowed to close the account.
        multi_signers: (optional) Signing accounts if `owner` is a multiSig.
        opts: (optional) Transaction options.
        recent_blockhash: (optional) a prefetched Blockhash for the transaction.
    """
    opts_to_use = TxOpts(preflight_commitment=self._conn.commitment) if opts is None else opts
    recent_blockhash_to_use = (
        (await self._conn.get_latest_blockhash()).value.blockhash if recent_blockhash is None else recent_blockhash
    )
    txn, opts = self._close_account_args(
        account, dest, authority, multi_signers, opts_to_use, recent_blockhash_to_use
    )
    return await self._conn.send_transaction(txn, opts=opts)

`create_account(self, owner, skip_confirmation=False, recent_blockhash=None)` `async`

Create and initialize a new account.

This account may then be used as a transfer() or approve() destination.

Parameters:

Name	Type	Description	Default
`owner`	`Pubkey`	User account that will own the new account.	required
`skip_confirmation`	`bool`	(optional) Option to skip transaction confirmation.	`False`
`recent_blockhash`	`optional`	A prefetched blockhash for the transaction.	`None`

Returns:

Type	Description
`Pubkey`	Public key of the new empty account.

If skip confirmation is set to False, this method will block for at most 30 seconds or until the transaction is confirmed.

Source code in spl/token/async_client.py

async def create_account(
    self,
    owner: Pubkey,
    skip_confirmation: bool = False,
    recent_blockhash: Optional[Blockhash] = None,
) -> Pubkey:
    """Create and initialize a new account.

    This account may then be used as a `transfer()` or `approve()` destination.

    Args:
        owner: User account that will own the new account.
        skip_confirmation: (optional) Option to skip transaction confirmation.
        recent_blockhash (optional): A prefetched blockhash for the transaction.

    Returns:
        Public key of the new empty account.

    If skip confirmation is set to `False`, this method will block for at most 30 seconds
    or until the transaction is confirmed.
    """
    balance_needed = await AsyncToken.get_min_balance_rent_for_exempt_for_account(self._conn)
    recent_blockhash_to_use = (
        (await self._conn.get_latest_blockhash()).value.blockhash if recent_blockhash is None else recent_blockhash
    )
    new_account_pk, txn, opts = self._create_account_args(
        owner, skip_confirmation, balance_needed, self._conn.commitment, recent_blockhash_to_use
    )
    # Send the two instructions
    await self._conn.send_transaction(txn, opts=opts)
    return new_account_pk

`create_associated_token_account(self, owner, skip_confirmation=False, recent_blockhash=None)` `async`

Create an associated token account.

Parameters:

Name	Type	Description	Default
`owner`	`Pubkey`	User account that will own the associated token account.	required
`skip_confirmation`	`bool`	(optional) Option to skip transaction confirmation.	`False`
`recent_blockhash`	`optional`	A prefetched blockhash for the transaction.	`None`

Returns:

Type	Description
`Pubkey`	Public key of the new associated account.

If skip confirmation is set to False, this method will block for at most 30 seconds or until the transaction is confirmed.

Source code in spl/token/async_client.py

async def create_associated_token_account(
    self,
    owner: Pubkey,
    skip_confirmation: bool = False,
    recent_blockhash: Optional[Blockhash] = None,
) -> Pubkey:
    """Create an associated token account.

    Args:
        owner: User account that will own the associated token account.
        skip_confirmation: (optional) Option to skip transaction confirmation.
        recent_blockhash (optional): A prefetched blockhash for the transaction.

    Returns:
        Public key of the new associated account.

    If skip confirmation is set to `False`, this method will block for at most 30 seconds
    or until the transaction is confirmed.
    """
    # Construct transaction
    recent_blockhash_to_use = (
        (await self._conn.get_latest_blockhash()).value.blockhash if recent_blockhash is None else recent_blockhash
    )
    public_key, txn, payer, opts = self._create_associated_token_account_args(
        owner, skip_confirmation, self._conn.commitment, recent_blockhash_to_use
    )
    await self._conn.send_transaction(txn, opts=opts)
    return public_key

`create_mint(conn, payer, mint_authority, decimals, program_id, freeze_authority=None, skip_confirmation=False, recent_blockhash=None)` `async` `classmethod`

Create and initialize a token.

Parameters:

Name	Type	Description	Default
`conn`	`AsyncClient`	RPC connection to a solana cluster.	required
`payer`	`Keypair`	Fee payer for transaction.	required
`mint_authority`	`Pubkey`	Account or multisig that will control minting.	required
`decimals`	`int`	Location of the decimal place.	required
`program_id`	`Pubkey`	SPL Token program account.	required
`freeze_authority`	`Optional[Pubkey]`	(optional) Account or multisig that can freeze token accounts.	`None`
`skip_confirmation`	`bool`	(optional) Option to skip transaction confirmation.	`False`
`recent_blockhash`	`Optional[Blockhash]`	(optional) a prefetched Blockhash for the transaction.	`None`

Returns:

Type	Description
`AsyncToken`	Token object for the newly minted token.

If skip confirmation is set to False, this method will block for at most 30 seconds or until the transaction is confirmed.

Source code in spl/token/async_client.py

@classmethod
async def create_mint(
    cls,
    conn: AsyncClient,
    payer: Keypair,
    mint_authority: Pubkey,
    decimals: int,
    program_id: Pubkey,
    freeze_authority: Optional[Pubkey] = None,
    skip_confirmation: bool = False,
    recent_blockhash: Optional[Blockhash] = None,
) -> AsyncToken:
    """Create and initialize a token.

    Args:
        conn: RPC connection to a solana cluster.
        payer: Fee payer for transaction.
        mint_authority: Account or multisig that will control minting.
        decimals: Location of the decimal place.
        program_id: SPL Token program account.
        freeze_authority: (optional) Account or multisig that can freeze token accounts.
        skip_confirmation: (optional) Option to skip transaction confirmation.
        recent_blockhash: (optional) a prefetched Blockhash for the transaction.

    Returns:
        Token object for the newly minted token.

    If skip confirmation is set to `False`, this method will block for at most 30 seconds
    or until the transaction is confirmed.
    """
    # Allocate memory for the account
    balance_needed = await AsyncToken.get_min_balance_rent_for_exempt_for_mint(conn)
    # Construct transaction
    recent_blockhash_to_use = (
        (await conn.get_latest_blockhash()).value.blockhash if recent_blockhash is None else recent_blockhash
    )
    token, txn, opts = _TokenCore._create_mint_args(
        conn,
        payer,
        mint_authority,
        decimals,
        program_id,
        freeze_authority,
        skip_confirmation,
        balance_needed,
        cls,
        conn.commitment,
        recent_blockhash_to_use,
    )
    # Send the two instructions
    await conn.send_transaction(txn, opts=opts)
    return cast(AsyncToken, token)

`create_multisig(self, m, multi_signers, opts=None, recent_blockhash=None)` `async`

Create and initialize a new multisig.

Parameters:

Name	Type	Description	Default
`m`	`int`	Number of required signatures.	required
`multi_signers`	`List[Pubkey]`	Full set of signers.	required
`opts`	`Optional[TxOpts]`	(optional) Transaction options.	`None`
`recent_blockhash`	`Optional[Blockhash]`	(optional) a prefetched Blockhash for the transaction.	`None`

Returns:

Type	Description
`Pubkey`	Public key of the new multisig account.

Source code in spl/token/async_client.py

async def create_multisig(
    self,
    m: int,
    multi_signers: List[Pubkey],
    opts: Optional[TxOpts] = None,
    recent_blockhash: Optional[Blockhash] = None,
) -> Pubkey:  # pylint: disable=invalid-name
    """Create and initialize a new multisig.

    Args:
        m: Number of required signatures.
        multi_signers: Full set of signers.
        opts: (optional) Transaction options.
        recent_blockhash: (optional) a prefetched Blockhash for the transaction.

    Returns:
        Public key of the new multisig account.
    """
    balance_needed = await AsyncToken.get_min_balance_rent_for_exempt_for_multisig(self._conn)
    recent_blockhash_to_use = (
        (await self._conn.get_latest_blockhash()).value.blockhash if recent_blockhash is None else recent_blockhash
    )
    txn, multisig = self._create_multisig_args(m, multi_signers, balance_needed, recent_blockhash_to_use)
    opts_to_use = TxOpts(preflight_commitment=self._conn.commitment) if opts is None else opts
    await self._conn.send_transaction(txn, opts=opts_to_use)
    return multisig.pubkey()

`create_wrapped_native_account(conn, program_id, owner, payer, amount, skip_confirmation=False, recent_blockhash=None)` `async` `staticmethod`

Create and initialize a new account on the special native token mint.

Parameters:

Name	Type	Description	Default
`conn`	`AsyncClient`	RPC connection to a solana cluster.	required
`program_id`	`Pubkey`	SPL Token program account.	required
`owner`	`Pubkey`	The owner of the new token account.	required
`payer`	`Keypair`	The source of the lamports to initialize, and payer of the initialization fees.	required
`amount`	`int`	The amount of lamports to wrap.	required
`skip_confirmation`	`bool`	(optional) Option to skip transaction confirmation.	`False`
`recent_blockhash`	`Optional[Blockhash]`	(optional) a prefetched Blockhash for the transaction.	`None`

Returns:

Type	Description
`Pubkey`	The new token account.

If skip confirmation is set to False, this method will block for at most 30 seconds or until the transaction is confirmed.

Source code in spl/token/async_client.py

@staticmethod
async def create_wrapped_native_account(
    conn: AsyncClient,
    program_id: Pubkey,
    owner: Pubkey,
    payer: Keypair,
    amount: int,
    skip_confirmation: bool = False,
    recent_blockhash: Optional[Blockhash] = None,
) -> Pubkey:
    """Create and initialize a new account on the special native token mint.

    Args:
        conn: RPC connection to a solana cluster.
        program_id: SPL Token program account.
        owner: The owner of the new token account.
        payer: The source of the lamports to initialize, and payer of the initialization fees.
        amount: The amount of lamports to wrap.
        skip_confirmation: (optional) Option to skip transaction confirmation.
        recent_blockhash: (optional) a prefetched Blockhash for the transaction.

    Returns:
        The new token account.

    If skip confirmation is set to `False`, this method will block for at most 30 seconds
    or until the transaction is confirmed.
    """
    # Allocate memory for the account
    balance_needed = await AsyncToken.get_min_balance_rent_for_exempt_for_account(conn)
    recent_blockhash_to_use = (
        (await conn.get_latest_blockhash()).value.blockhash if recent_blockhash is None else recent_blockhash
    )
    (new_account_public_key, txn, payer, new_account, opts,) = _TokenCore._create_wrapped_native_account_args(
        program_id,
        owner,
        payer,
        amount,
        skip_confirmation,
        balance_needed,
        conn.commitment,
        recent_blockhash_to_use,
    )
    await conn.send_transaction(txn, opts=opts)
    return new_account_public_key

`freeze_account(self, account, authority, multi_signers=None, opts=None, recent_blockhash=None)` `async`

Freeze account.

Parameters:

Name	Type	Description	Default
`account`	`Pubkey`	Account to freeze.	required
`authority`	`Pubkey`	The mint freeze authority.	required
`multi_signers`	`Optional[List[Keypair]]`	(optional) Signing accounts if `authority` is a multiSig.	`None`
`opts`	`Optional[TxOpts]`	(optional) Transaction options.	`None`
`recent_blockhash`	`Optional[Blockhash]`	(optional) a prefetched Blockhash for the transaction.	`None`

Source code in spl/token/async_client.py

async def freeze_account(
    self,
    account: Pubkey,
    authority: Pubkey,
    multi_signers: Optional[List[Keypair]] = None,
    opts: Optional[TxOpts] = None,
    recent_blockhash: Optional[Blockhash] = None,
) -> SendTransactionResp:
    """Freeze account.

    Args:
        account: Account to freeze.
        authority: The mint freeze authority.
        multi_signers: (optional) Signing accounts if `authority` is a multiSig.
        opts: (optional) Transaction options.
        recent_blockhash: (optional) a prefetched Blockhash for the transaction.
    """
    opts_to_use = TxOpts(preflight_commitment=self._conn.commitment) if opts is None else opts
    recent_blockhash_to_use = (
        (await self._conn.get_latest_blockhash()).value.blockhash if recent_blockhash is None else recent_blockhash
    )
    txn, opts = self._freeze_account_args(account, authority, multi_signers, opts_to_use, recent_blockhash_to_use)
    return await self._conn.send_transaction(txn, opts=opts)

`get_account_info(self, account, commitment=None)` `async`

Retrieve account information.

Source code in spl/token/async_client.py

async def get_account_info(self, account: Pubkey, commitment: Optional[Commitment] = None) -> AccountInfo:
    """Retrieve account information."""
    info = await self._conn.get_account_info(account, commitment)
    return self._create_account_info(info)

`get_accounts_by_delegate(self, owner, commitment=None, encoding='base64')` `async`

Get token accounts of the provided delegate.

Parameters:

Name	Type	Description	Default
`owner`	`Pubkey`	Public Key of the delegate account.	required
`commitment`	`Optional[Commitment]`	(optional) Bank state to query.	`None`
`encoding`	`str`	(optional) Encoding for Account data, either "base58" (slow) or "base64".	`'base64'`

Source code in spl/token/async_client.py

async def get_accounts_by_delegate(
    self,
    owner: Pubkey,
    commitment: Optional[Commitment] = None,
    encoding: str = "base64",
) -> GetTokenAccountsByDelegateResp:
    """Get token accounts of the provided delegate.

    Args:
        owner: Public Key of the delegate account.
        commitment: (optional) Bank state to query.
        encoding: (optional) Encoding for Account data, either "base58" (slow) or "base64".
    """
    args = self._get_accounts_args(
        owner,
        commitment,
        encoding,
        self._conn.commitment,  # pylint: disable=protected-access
    )
    return await self._conn.get_token_accounts_by_delegate(*args)

`get_accounts_by_delegate_json_parsed(self, owner, commitment=None, encoding='base64')` `async`

Get token accounts of the provided delegate, in JSON format.

Parameters:

Name	Type	Description	Default
`owner`	`Pubkey`	Public Key of the delegate account.	required
`commitment`	`Optional[Commitment]`	(optional) Bank state to query.	`None`
`encoding`	`str`	(optional) Encoding for Account data, either "base58" (slow) or "base64".	`'base64'`

Parsed-JSON encoding attempts to use program-specific state parsers to return more human-readable and explicit account state data. If parsed-JSON is requested but a valid mint cannot be found for a particular account, that account will be filtered out from results. jsonParsed encoding is UNSTABLE.

Source code in spl/token/async_client.py

async def get_accounts_by_delegate_json_parsed(
    self,
    owner: Pubkey,
    commitment: Optional[Commitment] = None,
    encoding: str = "base64",
) -> GetTokenAccountsByDelegateJsonParsedResp:
    """Get token accounts of the provided delegate, in JSON format.

    Args:
        owner: Public Key of the delegate account.
        commitment: (optional) Bank state to query.
        encoding: (optional) Encoding for Account data, either "base58" (slow) or "base64".

    Parsed-JSON encoding attempts to use program-specific state parsers to return more
    human-readable and explicit account state data. If parsed-JSON is requested but a
    valid mint cannot be found for a particular account, that account will be filtered out
    from results. jsonParsed encoding is UNSTABLE.
    """
    args = self._get_accounts_args(
        owner,
        commitment,
        encoding,
        self._conn.commitment,  # pylint: disable=protected-access
    )
    return await self._conn.get_token_accounts_by_delegate_json_parsed(*args)

`get_accounts_by_owner(self, owner, commitment=None, encoding='base64')` `async`

Get token accounts of the provided owner.

Parameters:

Name	Type	Description	Default
`owner`	`Pubkey`	Public Key of the token account owner.	required
`commitment`	`Optional[Commitment]`	(optional) Bank state to query.	`None`
`encoding`	`str`	(optional) Encoding for Account data, either "base58" (slow) or "base64".	`'base64'`

Source code in spl/token/async_client.py

async def get_accounts_by_owner(
    self,
    owner: Pubkey,
    commitment: Optional[Commitment] = None,
    encoding: str = "base64",
) -> GetTokenAccountsByOwnerResp:
    """Get token accounts of the provided owner.

    Args:
        owner: Public Key of the token account owner.
        commitment: (optional) Bank state to query.
        encoding: (optional) Encoding for Account data, either "base58" (slow) or "base64".
    """
    args = self._get_accounts_args(
        owner,
        commitment,
        encoding,
        self._conn.commitment,  # pylint: disable=protected-access
    )
    return await self._conn.get_token_accounts_by_owner(*args)

`get_accounts_by_owner_json_parsed(self, owner, commitment=None)` `async`

Get token accounts of the provided owner by the token's mint, in JSON format.

Parameters:

Name	Type	Description	Default
`owner`	`Pubkey`	Public Key of the token account owner.	required
`commitment`	`Optional[Commitment]`	(optional) Bank state to query.	`None`

Parsed-JSON encoding attempts to use program-specific state parsers to return more human-readable and explicit account state data. If parsed-JSON is requested but a valid mint cannot be found for a particular account, that account will be filtered out from results. jsonParsed encoding is UNSTABLE.

Source code in spl/token/async_client.py

async def get_accounts_by_owner_json_parsed(
    self,
    owner: Pubkey,
    commitment: Optional[Commitment] = None,
) -> GetTokenAccountsByOwnerJsonParsedResp:
    """Get token accounts of the provided owner by the token's mint, in JSON format.

    Args:
        owner: Public Key of the token account owner.
        commitment: (optional) Bank state to query.


    Parsed-JSON encoding attempts to use program-specific state parsers to return more
    human-readable and explicit account state data. If parsed-JSON is requested but a
    valid mint cannot be found for a particular account, that account will be filtered out
    from results. jsonParsed encoding is UNSTABLE.
    """
    args = self._get_accounts_args(
        owner,
        commitment,
        "jsonParsed",
        self._conn.commitment,  # pylint: disable=protected-access
    )
    return await self._conn.get_token_accounts_by_owner_json_parsed(*args)

`get_balance(self, pubkey, commitment=None)` `async`

Get the balance of the provided token account.

Parameters:

Name	Type	Description	Default
`pubkey`	`Pubkey`	Public Key of the token account.	required
`commitment`	`Optional[Commitment]`	(optional) Bank state to query.	`None`

Source code in spl/token/async_client.py

async def get_balance(self, pubkey: Pubkey, commitment: Optional[Commitment] = None) -> GetTokenAccountBalanceResp:
    """Get the balance of the provided token account.

    Args:
        pubkey: Public Key of the token account.
        commitment: (optional) Bank state to query.
    """
    return await self._conn.get_token_account_balance(pubkey, commitment)

`get_min_balance_rent_for_exempt_for_account(conn)` `async` `staticmethod`

Get the minimum balance for the account to be rent exempt.

Parameters:

Name	Type	Description	Default
`conn`	`AsyncClient`	RPC connection to a solana cluster.	required

Returns:

Type	Description
`int`	Number of lamports required.

Source code in spl/token/async_client.py

@staticmethod
async def get_min_balance_rent_for_exempt_for_account(conn: AsyncClient) -> int:
    """Get the minimum balance for the account to be rent exempt.

    Args:
        conn: RPC connection to a solana cluster.

    Returns:
        Number of lamports required.
    """
    resp = await conn.get_minimum_balance_for_rent_exemption(ACCOUNT_LAYOUT.sizeof())
    return resp.value

`get_min_balance_rent_for_exempt_for_mint(conn)` `async` `staticmethod`

Get the minimum balance for the mint to be rent exempt.

Parameters:

Name	Type	Description	Default
`conn`	`AsyncClient`	RPC connection to a solana cluster.	required

Returns:

Type	Description
`int`	Number of lamports required.

Source code in spl/token/async_client.py

@staticmethod
async def get_min_balance_rent_for_exempt_for_mint(conn: AsyncClient) -> int:
    """Get the minimum balance for the mint to be rent exempt.

    Args:
        conn: RPC connection to a solana cluster.

    Returns:
        Number of lamports required.
    """
    resp = await conn.get_minimum_balance_for_rent_exemption(MINT_LAYOUT.sizeof())
    return resp.value

`get_min_balance_rent_for_exempt_for_multisig(conn)` `async` `staticmethod`

Get the minimum balance for the multisig to be rent exempt.

Parameters:

Name	Type	Description	Default
`conn`	`AsyncClient`	RPC connection to a solana cluster.	required

Returns:

Type	Description
`int`	Number of lamports required.

Source code in spl/token/async_client.py

@staticmethod
async def get_min_balance_rent_for_exempt_for_multisig(conn: AsyncClient) -> int:
    """Get the minimum balance for the multisig to be rent exempt.

    Args:
        conn: RPC connection to a solana cluster.

    Returns:
         Number of lamports required.
    """
    resp = await conn.get_minimum_balance_for_rent_exemption(MULTISIG_LAYOUT.sizeof())
    return resp.value

`get_mint_info(self)` `async`

Retrieve mint information.

Source code in spl/token/async_client.py

async def get_mint_info(self) -> MintInfo:
    """Retrieve mint information."""
    info = await self._conn.get_account_info(self.pubkey)
    return self._create_mint_info(info)

`mint_to(self, dest, mint_authority, amount, multi_signers=None, opts=None, recent_blockhash=None)` `async`

Mint new tokens.

Parameters:

Name	Type	Description	Default
`dest`	`Pubkey`	Public key of the account to mint to.	required
`mint_authority`	`Union[Keypair, Pubkey]`	Public key of the minting authority.	required
`amount`	`int`	Amount to mint.	required
`multi_signers`	`Optional[List[Keypair]]`	(optional) Signing accounts if `owner` is a multisig.	`None`
`opts`	`Optional[TxOpts]`	(optional) Transaction options.	`None`
`recent_blockhash`	`Optional[Blockhash]`	(optional) a prefetched Blockhash for the transaction.	`None`

If skip confirmation is set to False, this method will block for at most 30 seconds or until the transaction is confirmed.

Source code in spl/token/async_client.py

async def mint_to(
    self,
    dest: Pubkey,
    mint_authority: Union[Keypair, Pubkey],
    amount: int,
    multi_signers: Optional[List[Keypair]] = None,
    opts: Optional[TxOpts] = None,
    recent_blockhash: Optional[Blockhash] = None,
) -> SendTransactionResp:
    """Mint new tokens.

    Args:
        dest: Public key of the account to mint to.
        mint_authority: Public key of the minting authority.
        amount: Amount to mint.
        multi_signers: (optional) Signing accounts if `owner` is a multisig.
        opts: (optional) Transaction options.
        recent_blockhash: (optional) a prefetched Blockhash for the transaction.

    If skip confirmation is set to `False`, this method will block for at most 30 seconds
    or until the transaction is confirmed.
    """
    opts_to_use = TxOpts(preflight_commitment=self._conn.commitment) if opts is None else opts
    recent_blockhash_to_use = (
        (await self._conn.get_latest_blockhash()).value.blockhash if recent_blockhash is None else recent_blockhash
    )
    txn, opts = self._mint_to_args(
        dest, mint_authority, amount, multi_signers, opts_to_use, recent_blockhash_to_use
    )
    return await self._conn.send_transaction(txn, opts=opts)

`mint_to_checked(self, dest, mint_authority, amount, decimals, multi_signers=None, opts=None, recent_blockhash=None)` `async`

Mint new tokens, asserting the token mint and decimals.

Parameters:

Name	Type	Description	Default
`dest`	`Pubkey`	Public key of the account to mint to.	required
`mint_authority`	`Pubkey`	Public key of the minting authority.	required
`amount`	`int`	Amount to mint.	required
`decimals`	`int`	Number of decimals in amount to mint.	required
`multi_signers`	`Optional[List[Keypair]]`	(optional) Signing accounts if `owner` is a multiSig.	`None`
`opts`	`Optional[TxOpts]`	(optional) Transaction options.	`None`
`recent_blockhash`	`optional`	A prefetched blockhash for the transaction.	`None`

Source code in spl/token/async_client.py

async def mint_to_checked(
    self,
    dest: Pubkey,
    mint_authority: Pubkey,
    amount: int,
    decimals: int,
    multi_signers: Optional[List[Keypair]] = None,
    opts: Optional[TxOpts] = None,
    recent_blockhash: Optional[Blockhash] = None,
) -> SendTransactionResp:
    """Mint new tokens, asserting the token mint and decimals.

    Args:
        dest: Public key of the account to mint to.
        mint_authority: Public key of the minting authority.
        amount: Amount to mint.
        decimals: Number of decimals in amount to mint.
        multi_signers: (optional) Signing accounts if `owner` is a multiSig.
        opts: (optional) Transaction options.
        recent_blockhash (optional): A prefetched blockhash for the transaction.
    """
    opts_to_use = TxOpts(preflight_commitment=self._conn.commitment) if opts is None else opts
    recent_blockhash_to_use = (
        (await self._conn.get_latest_blockhash()).value.blockhash if recent_blockhash is None else recent_blockhash
    )
    txn, opts = self._mint_to_checked_args(
        dest, mint_authority, amount, decimals, multi_signers, opts_to_use, recent_blockhash_to_use
    )
    return await self._conn.send_transaction(txn, opts=opts)

`revoke(self, account, owner, multi_signers=None, opts=None, recent_blockhash=None)` `async`

Revoke transfer authority for a given account.

Parameters:

Name	Type	Description	Default
`account`	`Pubkey`	Source account for which transfer authority is being revoked.	required
`owner`	`Pubkey`	Owner of the source account.	required
`multi_signers`	`Optional[List[Keypair]]`	(optional) Signing accounts if `owner` is a multisig.	`None`
`opts`	`Optional[TxOpts]`	(optional) Transaction options.	`None`
`recent_blockhash`	`Optional[Blockhash]`	(optional) a prefetched Blockhash for the transaction.	`None`

Source code in spl/token/async_client.py

async def revoke(
    self,
    account: Pubkey,
    owner: Pubkey,
    multi_signers: Optional[List[Keypair]] = None,
    opts: Optional[TxOpts] = None,
    recent_blockhash: Optional[Blockhash] = None,
) -> SendTransactionResp:
    """Revoke transfer authority for a given account.

    Args:
        account: Source account for which transfer authority is being revoked.
        owner: Owner of the source account.
        multi_signers: (optional) Signing accounts if `owner` is a multisig.
        opts: (optional) Transaction options.
        recent_blockhash: (optional) a prefetched Blockhash for the transaction.
    """
    opts_to_use = TxOpts(preflight_commitment=self._conn.commitment) if opts is None else opts
    recent_blockhash_to_use = (
        (await self._conn.get_latest_blockhash()).value.blockhash if recent_blockhash is None else recent_blockhash
    )
    txn, payer, signers, opts = self._revoke_args(
        account, owner, multi_signers, opts_to_use, recent_blockhash_to_use
    )
    return await self._conn.send_transaction(txn, opts=opts)

`set_authority(self, account, current_authority, authority_type, new_authority=None, multi_signers=None, opts=None, recent_blockhash=None)` `async`

Assign a new authority to the account.

Parameters:

Name	Type	Description	Default
`account`	`Pubkey`	Public key of the token account.	required
`current_authority`	`Union[Keypair, Pubkey]`	Current authority of the account.	required
`authority_type`	`spl_token.AuthorityType`	Type of authority to set.	required
`new_authority`	`Optional[Pubkey]`	(optional) New authority of the account.	`None`
`multi_signers`	`Optional[List[Keypair]]`	(optional) Signing accounts if `owner` is a multiSig.	`None`
`opts`	`Optional[TxOpts]`	(optional) Transaction options.	`None`
`recent_blockhash`	`Optional[Blockhash]`	(optional) a prefetched Blockhash for the transaction.	`None`

Source code in spl/token/async_client.py

async def set_authority(
    self,
    account: Pubkey,
    current_authority: Union[Keypair, Pubkey],
    authority_type: spl_token.AuthorityType,
    new_authority: Optional[Pubkey] = None,
    multi_signers: Optional[List[Keypair]] = None,
    opts: Optional[TxOpts] = None,
    recent_blockhash: Optional[Blockhash] = None,
) -> SendTransactionResp:
    """Assign a new authority to the account.

    Args:
        account: Public key of the token account.
        current_authority: Current authority of the account.
        authority_type: Type of authority to set.
        new_authority: (optional) New authority of the account.
        multi_signers: (optional) Signing accounts if `owner` is a multiSig.
        opts: (optional) Transaction options.
        recent_blockhash: (optional) a prefetched Blockhash for the transaction.
    """
    opts_to_use = TxOpts(preflight_commitment=self._conn.commitment) if opts is None else opts
    recent_blockhash_to_use = (
        (await self._conn.get_latest_blockhash()).value.blockhash if recent_blockhash is None else recent_blockhash
    )
    txn, payer, signers, opts = self._set_authority_args(
        account,
        current_authority,
        authority_type,
        new_authority,
        multi_signers,
        opts_to_use,
        recent_blockhash_to_use,
    )
    return await self._conn.send_transaction(txn, opts=opts)

`thaw_account(self, account, authority, multi_signers=None, opts=None, recent_blockhash=None)` `async`

Thaw account.

Parameters:

Name	Type	Description	Default
`account`	`Pubkey`	Account to thaw.	required
`authority`	`Pubkey`	The mint freeze authority.	required
`multi_signers`	`Optional[List[Keypair]]`	(optional) Signing accounts if `authority` is a multiSig.	`None`
`opts`	`Optional[TxOpts]`	(optional) Transaction options.	`None`
`recent_blockhash`	`Optional[Blockhash]`	(optional) a prefetched Blockhash for the transaction.	`None`

Source code in spl/token/async_client.py

async def thaw_account(
    self,
    account: Pubkey,
    authority: Pubkey,
    multi_signers: Optional[List[Keypair]] = None,
    opts: Optional[TxOpts] = None,
    recent_blockhash: Optional[Blockhash] = None,
) -> SendTransactionResp:
    """Thaw account.

    Args:
        account: Account to thaw.
        authority: The mint freeze authority.
        multi_signers: (optional) Signing accounts if `authority` is a multiSig.
        opts: (optional) Transaction options.
        recent_blockhash: (optional) a prefetched Blockhash for the transaction.
    """
    opts_to_use = TxOpts(preflight_commitment=self._conn.commitment) if opts is None else opts
    recent_blockhash_to_use = (
        (await self._conn.get_latest_blockhash()).value.blockhash if recent_blockhash is None else recent_blockhash
    )
    txn, opts = self._thaw_account_args(account, authority, multi_signers, opts_to_use, recent_blockhash_to_use)
    return await self._conn.send_transaction(txn, opts=opts)

`transfer(self, source, dest, owner, amount, multi_signers=None, opts=None, recent_blockhash=None)` `async`

Transfer tokens to another account.

Parameters:

Name	Type	Description	Default
`source`	`Pubkey`	Public key of account to transfer tokens from.	required
`dest`	`Pubkey`	Public key of account to transfer tokens to.	required
`owner`	`Union[Keypair, Pubkey]`	Owner of the source account.	required
`amount`	`int`	Number of tokens to transfer.	required
`multi_signers`	`Optional[List[Keypair]]`	(optional) Signing accounts if `owner` is a multiSig.	`None`
`opts`	`Optional[TxOpts]`	(optional) Transaction options.	`None`
`recent_blockhash`	`Optional[Blockhash]`	(optional) a prefetched Blockhash for the transaction.	`None`

Source code in spl/token/async_client.py

async def transfer(
    self,
    source: Pubkey,
    dest: Pubkey,
    owner: Union[Keypair, Pubkey],
    amount: int,
    multi_signers: Optional[List[Keypair]] = None,
    opts: Optional[TxOpts] = None,
    recent_blockhash: Optional[Blockhash] = None,
) -> SendTransactionResp:
    """Transfer tokens to another account.

    Args:
        source: Public key of account to transfer tokens from.
        dest: Public key of account to transfer tokens to.
        owner: Owner of the source account.
        amount: Number of tokens to transfer.
        multi_signers: (optional) Signing accounts if `owner` is a multiSig.
        opts: (optional) Transaction options.
        recent_blockhash: (optional) a prefetched Blockhash for the transaction.
    """
    opts_to_use = TxOpts(preflight_commitment=self._conn.commitment) if opts is None else opts
    recent_blockhash_to_use = (
        (await self._conn.get_latest_blockhash()).value.blockhash if recent_blockhash is None else recent_blockhash
    )
    txn, opts = self._transfer_args(
        source, dest, owner, amount, multi_signers, opts_to_use, recent_blockhash_to_use
    )
    return await self._conn.send_transaction(txn, opts=opts)

`transfer_checked(self, source, dest, owner, amount, decimals, multi_signers, opts=None, recent_blockhash=None)` `async`

Transfer tokens to another account, asserting the token mint and decimals.

Parameters:

Name	Type	Description	Default
`source`	`Pubkey`	Public key of account to transfer tokens from.	required
`dest`	`Pubkey`	Public key of account to transfer tokens to.	required
`owner`	`Pubkey`	Owner of the source account.	required
`amount`	`int`	Number of tokens to transfer.	required
`decimals`	`int`	Number of decimals in transfer amount.	required
`multi_signers`	`Optional[List[Keypair]]`	(optional) Signing accounts if `owner` is a multiSig.	required
`opts`	`Optional[TxOpts]`	(optional) Transaction options.	`None`
`recent_blockhash`	`Optional[Blockhash]`	(optional) a prefetched Blockhash for the transaction.	`None`

Source code in spl/token/async_client.py

async def transfer_checked(
    self,
    source: Pubkey,
    dest: Pubkey,
    owner: Pubkey,
    amount: int,
    decimals: int,
    multi_signers: Optional[List[Keypair]],
    opts: Optional[TxOpts] = None,
    recent_blockhash: Optional[Blockhash] = None,
) -> SendTransactionResp:
    """Transfer tokens to another account, asserting the token mint and decimals.

    Args:
        source: Public key of account to transfer tokens from.
        dest: Public key of account to transfer tokens to.
        owner: Owner of the source account.
        amount: Number of tokens to transfer.
        decimals: Number of decimals in transfer amount.
        multi_signers: (optional) Signing accounts if `owner` is a multiSig.
        opts: (optional) Transaction options.
        recent_blockhash: (optional) a prefetched Blockhash for the transaction.
    """
    opts_to_use = TxOpts(preflight_commitment=self._conn.commitment) if opts is None else opts
    recent_blockhash_to_use = (
        (await self._conn.get_latest_blockhash()).value.blockhash if recent_blockhash is None else recent_blockhash
    )
    txn, opts = self._transfer_checked_args(
        source, dest, owner, amount, decimals, multi_signers, opts_to_use, recent_blockhash_to_use
    )
    return await self._conn.send_transaction(txn, opts=opts)

Async Client

spl.token.async_client

AsyncToken

approve(self, source, delegate, owner, amount, multi_signers=None, opts=None, recent_blockhash=None) async

approve_checked(self, source, delegate, owner, amount, decimals, multi_signers=None, opts=None, recent_blockhash=None) async

burn(self, account, owner, amount, multi_signers=None, opts=None, recent_blockhash=None) async

burn_checked(self, account, owner, amount, decimals, multi_signers=None, opts=None, recent_blockhash=None) async

close_account(self, account, dest, authority, multi_signers=None, opts=None, recent_blockhash=None) async

create_account(self, owner, skip_confirmation=False, recent_blockhash=None) async

create_associated_token_account(self, owner, skip_confirmation=False, recent_blockhash=None) async

create_mint(conn, payer, mint_authority, decimals, program_id, freeze_authority=None, skip_confirmation=False, recent_blockhash=None) async classmethod

create_multisig(self, m, multi_signers, opts=None, recent_blockhash=None) async

create_wrapped_native_account(conn, program_id, owner, payer, amount, skip_confirmation=False, recent_blockhash=None) async staticmethod

freeze_account(self, account, authority, multi_signers=None, opts=None, recent_blockhash=None) async

get_account_info(self, account, commitment=None) async

get_accounts_by_delegate(self, owner, commitment=None, encoding='base64') async

get_accounts_by_delegate_json_parsed(self, owner, commitment=None, encoding='base64') async

get_accounts_by_owner(self, owner, commitment=None, encoding='base64') async

get_accounts_by_owner_json_parsed(self, owner, commitment=None) async

get_balance(self, pubkey, commitment=None) async

get_min_balance_rent_for_exempt_for_account(conn) async staticmethod

get_min_balance_rent_for_exempt_for_mint(conn) async staticmethod

get_min_balance_rent_for_exempt_for_multisig(conn) async staticmethod

get_mint_info(self) async

mint_to(self, dest, mint_authority, amount, multi_signers=None, opts=None, recent_blockhash=None) async

mint_to_checked(self, dest, mint_authority, amount, decimals, multi_signers=None, opts=None, recent_blockhash=None) async

revoke(self, account, owner, multi_signers=None, opts=None, recent_blockhash=None) async

set_authority(self, account, current_authority, authority_type, new_authority=None, multi_signers=None, opts=None, recent_blockhash=None) async

thaw_account(self, account, authority, multi_signers=None, opts=None, recent_blockhash=None) async

transfer(self, source, dest, owner, amount, multi_signers=None, opts=None, recent_blockhash=None) async

transfer_checked(self, source, dest, owner, amount, decimals, multi_signers, opts=None, recent_blockhash=None) async

`spl.token.async_client`

`AsyncToken`

`approve(self, source, delegate, owner, amount, multi_signers=None, opts=None, recent_blockhash=None)` `async`

`approve_checked(self, source, delegate, owner, amount, decimals, multi_signers=None, opts=None, recent_blockhash=None)` `async`

`burn(self, account, owner, amount, multi_signers=None, opts=None, recent_blockhash=None)` `async`

`burn_checked(self, account, owner, amount, decimals, multi_signers=None, opts=None, recent_blockhash=None)` `async`

`close_account(self, account, dest, authority, multi_signers=None, opts=None, recent_blockhash=None)` `async`

`create_account(self, owner, skip_confirmation=False, recent_blockhash=None)` `async`

`create_associated_token_account(self, owner, skip_confirmation=False, recent_blockhash=None)` `async`

`create_mint(conn, payer, mint_authority, decimals, program_id, freeze_authority=None, skip_confirmation=False, recent_blockhash=None)` `async` `classmethod`

`create_multisig(self, m, multi_signers, opts=None, recent_blockhash=None)` `async`

`create_wrapped_native_account(conn, program_id, owner, payer, amount, skip_confirmation=False, recent_blockhash=None)` `async` `staticmethod`

`freeze_account(self, account, authority, multi_signers=None, opts=None, recent_blockhash=None)` `async`

`get_account_info(self, account, commitment=None)` `async`

`get_accounts_by_delegate(self, owner, commitment=None, encoding='base64')` `async`

`get_accounts_by_delegate_json_parsed(self, owner, commitment=None, encoding='base64')` `async`

`get_accounts_by_owner(self, owner, commitment=None, encoding='base64')` `async`

`get_accounts_by_owner_json_parsed(self, owner, commitment=None)` `async`

`get_balance(self, pubkey, commitment=None)` `async`

`get_min_balance_rent_for_exempt_for_account(conn)` `async` `staticmethod`

`get_min_balance_rent_for_exempt_for_mint(conn)` `async` `staticmethod`

`get_min_balance_rent_for_exempt_for_multisig(conn)` `async` `staticmethod`

`get_mint_info(self)` `async`

`mint_to(self, dest, mint_authority, amount, multi_signers=None, opts=None, recent_blockhash=None)` `async`

`mint_to_checked(self, dest, mint_authority, amount, decimals, multi_signers=None, opts=None, recent_blockhash=None)` `async`

`revoke(self, account, owner, multi_signers=None, opts=None, recent_blockhash=None)` `async`

`set_authority(self, account, current_authority, authority_type, new_authority=None, multi_signers=None, opts=None, recent_blockhash=None)` `async`

`thaw_account(self, account, authority, multi_signers=None, opts=None, recent_blockhash=None)` `async`

`transfer(self, source, dest, owner, amount, multi_signers=None, opts=None, recent_blockhash=None)` `async`

`transfer_checked(self, source, dest, owner, amount, decimals, multi_signers, opts=None, recent_blockhash=None)` `async`