Client

SPL Token program client.

`Token (_TokenCore)`

An ERC20-like Token.

Source code in spl/token/client.py

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

    def __init__(self, conn: Client, 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
    def get_min_balance_rent_for_exempt_for_account(conn: Client) -> 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 = conn.get_minimum_balance_for_rent_exemption(ACCOUNT_LAYOUT.sizeof())
        return resp.value

    @staticmethod
    def get_min_balance_rent_for_exempt_for_mint(conn: Client) -> 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 = conn.get_minimum_balance_for_rent_exemption(MINT_LAYOUT.sizeof())
        return resp.value

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

        Args:
            conn: RPC connection to a solana cluster.

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

    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 self._conn.get_token_accounts_by_owner(*args)

    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 self._conn.get_token_accounts_by_owner_json_parsed(*args)

    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 self._conn.get_token_accounts_by_delegate(*args)

    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 self._conn.get_token_accounts_by_delegate_json_parsed(*args)

    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 self._conn.get_token_account_balance(pubkey, commitment)

    @classmethod
    def create_mint(
        cls,
        conn: Client,
        payer: Keypair,
        mint_authority: Pubkey,
        decimals: int,
        program_id: Pubkey,
        freeze_authority: Optional[Pubkey] = None,
        skip_confirmation: bool = False,
        recent_blockhash: Optional[Blockhash] = None,
    ) -> Token:
        """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 = Token.get_min_balance_rent_for_exempt_for_mint(conn)
        # Construct transaction
        recent_blockhash_to_use = (
            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
        conn.send_transaction(txn, opts=opts)
        return cast(Token, token)

    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 = Token.get_min_balance_rent_for_exempt_for_account(self._conn)
        recent_blockhash_to_use = (
            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
        self._conn.send_transaction(txn, opts=opts)
        return new_account_pk

    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 = (
            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, token_program_id=self.program_id
        )
        self._conn.send_transaction(txn, opts=opts)
        return public_key

    @staticmethod
    def create_wrapped_native_account(
        conn: Client,
        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 = Token.get_min_balance_rent_for_exempt_for_account(conn)
        recent_blockhash_to_use = (
            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,
        )
        conn.send_transaction(txn, opts=opts)
        return new_account_public_key

    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 = Token.get_min_balance_rent_for_exempt_for_multisig(self._conn)
        recent_blockhash_to_use = (
            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
        self._conn.send_transaction(txn, opts=opts_to_use)
        return multisig.pubkey()

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

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

    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 = (
            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 self._conn.send_transaction(txn, opts=opts)

    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 = (
            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 self._conn.send_transaction(txn, opts=opts)

    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 = (
            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 self._conn.send_transaction(txn, opts=opts)

    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 = (
            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 self._conn.send_transaction(txn, opts=opts)

    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 = (
            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 self._conn.send_transaction(txn, opts=opts)

    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 = (
            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 self._conn.send_transaction(txn, opts=opts)

    def close_account(
        self,
        account: Pubkey,
        dest: Pubkey,
        authority: Union[Keypair, 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 = (
            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 self._conn.send_transaction(txn, opts=opts)

    def freeze_account(
        self,
        account: Pubkey,
        authority: Union[Pubkey, Keypair],
        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 = (
            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 self._conn.send_transaction(txn, opts=opts)

    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 = (
            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 self._conn.send_transaction(txn, opts=opts)

    def transfer_checked(
        self,
        source: Pubkey,
        dest: Pubkey,
        owner: Union[Keypair, Pubkey],
        amount: int,
        decimals: int,
        multi_signers: Optional[List[Keypair]] = None,
        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 = (
            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 self._conn.send_transaction(txn, opts=opts)

    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 = (
            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 self._conn.send_transaction(txn, opts=opts)

    def mint_to_checked(
        self,
        dest: Pubkey,
        mint_authority: Union[Keypair, 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 = (
            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 self._conn.send_transaction(txn, opts=opts)

    def burn_checked(
        self,
        account: Pubkey,
        owner: Union[Keypair, 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 = (
            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 self._conn.send_transaction(txn, opts=opts)

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

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/client.py

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 = (
        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 self._conn.send_transaction(txn, opts=opts)

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

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[Blockhash]`	(optional) a prefetched Blockhash for the transaction.	`None`

Source code in spl/token/client.py

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 = (
        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 self._conn.send_transaction(txn, opts=opts)

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

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/client.py

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 = (
        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 self._conn.send_transaction(txn, opts=opts)

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

Burn tokens, asserting the token mint and decimals.

Parameters:

Name	Type	Description	Default
`account`	`Pubkey`	Account to burn tokens from.	required
`owner`	`Union[Keypair, 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/client.py

def burn_checked(
    self,
    account: Pubkey,
    owner: Union[Keypair, 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 = (
        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 self._conn.send_transaction(txn, opts=opts)

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

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`	`Union[Keypair, 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/client.py

def close_account(
    self,
    account: Pubkey,
    dest: Pubkey,
    authority: Union[Keypair, 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 = (
        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 self._conn.send_transaction(txn, opts=opts)

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

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[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/client.py

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 = Token.get_min_balance_rent_for_exempt_for_account(self._conn)
    recent_blockhash_to_use = (
        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
    self._conn.send_transaction(txn, opts=opts)
    return new_account_pk

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

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[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/client.py

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 = (
        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, token_program_id=self.program_id
    )
    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)` `classmethod`

Create and initialize a token.

Parameters:

Name	Type	Description	Default
`conn`	`Client`	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
`Token`	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/client.py

@classmethod
def create_mint(
    cls,
    conn: Client,
    payer: Keypair,
    mint_authority: Pubkey,
    decimals: int,
    program_id: Pubkey,
    freeze_authority: Optional[Pubkey] = None,
    skip_confirmation: bool = False,
    recent_blockhash: Optional[Blockhash] = None,
) -> Token:
    """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 = Token.get_min_balance_rent_for_exempt_for_mint(conn)
    # Construct transaction
    recent_blockhash_to_use = (
        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
    conn.send_transaction(txn, opts=opts)
    return cast(Token, token)

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

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/client.py

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 = Token.get_min_balance_rent_for_exempt_for_multisig(self._conn)
    recent_blockhash_to_use = (
        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
    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)` `staticmethod`

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

Parameters:

Name	Type	Description	Default
`conn`	`Client`	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/client.py

@staticmethod
def create_wrapped_native_account(
    conn: Client,
    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 = Token.get_min_balance_rent_for_exempt_for_account(conn)
    recent_blockhash_to_use = (
        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,
    )
    conn.send_transaction(txn, opts=opts)
    return new_account_public_key

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

Freeze account.

Parameters:

Name	Type	Description	Default
`account`	`Pubkey`	Account to freeze.	required
`authority`	`Union[Pubkey, Keypair]`	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/client.py

def freeze_account(
    self,
    account: Pubkey,
    authority: Union[Pubkey, Keypair],
    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 = (
        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 self._conn.send_transaction(txn, opts=opts)

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

Retrieve account information.

Source code in spl/token/client.py

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

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

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/client.py

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 self._conn.get_token_accounts_by_delegate(*args)

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

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/client.py

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 self._conn.get_token_accounts_by_delegate_json_parsed(*args)

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

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/client.py

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 self._conn.get_token_accounts_by_owner(*args)

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

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/client.py

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 self._conn.get_token_accounts_by_owner_json_parsed(*args)

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

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/client.py

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 self._conn.get_token_account_balance(pubkey, commitment)

`get_min_balance_rent_for_exempt_for_account(conn)` `staticmethod`

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

Parameters:

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

Returns:

Type	Description
`int`	Number of lamports required.

Source code in spl/token/client.py

@staticmethod
def get_min_balance_rent_for_exempt_for_account(conn: Client) -> 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 = conn.get_minimum_balance_for_rent_exemption(ACCOUNT_LAYOUT.sizeof())
    return resp.value

`get_min_balance_rent_for_exempt_for_mint(conn)` `staticmethod`

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

Parameters:

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

Returns:

Type	Description
`int`	Number of lamports required.

Source code in spl/token/client.py

@staticmethod
def get_min_balance_rent_for_exempt_for_mint(conn: Client) -> 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 = conn.get_minimum_balance_for_rent_exemption(MINT_LAYOUT.sizeof())
    return resp.value

`get_min_balance_rent_for_exempt_for_multisig(conn)` `staticmethod`

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

Parameters:

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

Source code in spl/token/client.py

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

    Args:
        conn: RPC connection to a solana cluster.

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

`get_mint_info(self)`

Retrieve mint information.

Source code in spl/token/client.py

def get_mint_info(self) -> MintInfo:
    """Retrieve mint information."""
    info = 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)`

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/client.py

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 = (
        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 self._conn.send_transaction(txn, opts=opts)

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

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`	`Union[Keypair, 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[Blockhash]`	(optional) a prefetched Blockhash for the transaction.	`None`

Source code in spl/token/client.py

def mint_to_checked(
    self,
    dest: Pubkey,
    mint_authority: Union[Keypair, 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 = (
        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 self._conn.send_transaction(txn, opts=opts)

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

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/client.py

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 = (
        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 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)`

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/client.py

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 = (
        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 self._conn.send_transaction(txn, opts=opts)

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

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/client.py

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 = (
        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 self._conn.send_transaction(txn, opts=opts)

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

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/client.py

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 = (
        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 self._conn.send_transaction(txn, opts=opts)

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

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`	`Union[Keypair, 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.	`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/client.py

def transfer_checked(
    self,
    source: Pubkey,
    dest: Pubkey,
    owner: Union[Keypair, Pubkey],
    amount: int,
    decimals: int,
    multi_signers: Optional[List[Keypair]] = None,
    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 = (
        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 self._conn.send_transaction(txn, opts=opts)

Client

Token (_TokenCore)

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

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

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

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

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

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

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

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

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

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

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

get_account_info(self, account, commitment=None)

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

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

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

get_accounts_by_owner_json_parsed(self, owner, commitment=None)

get_balance(self, pubkey, commitment=None)

get_min_balance_rent_for_exempt_for_account(conn) staticmethod

get_min_balance_rent_for_exempt_for_mint(conn) staticmethod

get_min_balance_rent_for_exempt_for_multisig(conn) staticmethod

get_mint_info(self)

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

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

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

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

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

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

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

`Token (_TokenCore)`

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

`get_min_balance_rent_for_exempt_for_account(conn)` `staticmethod`

`get_min_balance_rent_for_exempt_for_mint(conn)` `staticmethod`

`get_min_balance_rent_for_exempt_for_multisig(conn)` `staticmethod`

`get_mint_info(self)`

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

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

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

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

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

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

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