Client

spl.token.client

SPL Token program client.

Token

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
        )
        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
    )
    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)