def _create_mint_info(self, info: RPCResponse) -> MintInfo: if not info: raise ValueError("Failed to find mint account") owner = info["result"]["value"]["owner"] if owner != str(self.program_id): raise AttributeError(f"Invalid mint owner: {owner}") bytes_data = decode_byte_string(info["result"]["value"]["data"][0]) if len(bytes_data) != MINT_LAYOUT.sizeof(): raise ValueError("Invalid mint size") decoded_data = MINT_LAYOUT.parse(bytes_data) decimals = decoded_data.decimals if decoded_data.mint_authority_option == 0: mint_authority = None else: mint_authority = PublicKey(decoded_data.mint_authority) supply = decoded_data.supply is_initialized = decoded_data.is_initialized != 0 if decoded_data.freeze_authority_option == 0: freeze_authority = None else: freeze_authority = PublicKey(decoded_data.freeze_authority) return MintInfo(mint_authority, supply, decimals, is_initialized, freeze_authority)
async def create_mint(client: AsyncClient, payer: Keypair, mint: Keypair, mint_authority: PublicKey): mint_balance = await AsyncToken.get_min_balance_rent_for_exempt_for_mint( client) print(f"Creating pool token mint {mint.public_key}") txn = Transaction() txn.add( sys.create_account( sys.CreateAccountParams( from_pubkey=payer.public_key, new_account_pubkey=mint.public_key, lamports=mint_balance, space=MINT_LAYOUT.sizeof(), program_id=TOKEN_PROGRAM_ID, ))) txn.add( spl_token.initialize_mint( spl_token.InitializeMintParams( program_id=TOKEN_PROGRAM_ID, mint=mint.public_key, decimals=9, mint_authority=mint_authority, freeze_authority=None, ))) await client.send_transaction(txn, payer, mint, opts=TxOpts(skip_confirmation=False, preflight_commitment=Confirmed))
def get_min_balance_rent_for_exempt_for_mint(conn: Client) -> int: """Get the minimum balance for the mint to be rent exempt. :param conn: RPC connection to a solana cluster. :return: Number of lamports required. """ resp = conn.get_minimum_balance_for_rent_exemption(MINT_LAYOUT.sizeof()) return resp["result"]
def create_mint( conn: Client, payer: Account, mint_authority: PublicKey, decimals: int, program_id: PublicKey, freeze_authority: Optional[PublicKey] = None, skip_confirmation: bool = False, ) -> Token: """Create and initialize a token. :param conn: RPC connection to a solana cluster. :param payer: Fee payer for transaction. :param mint_authority: Account or multisig that will control minting. :param decimals: Location of the decimal place. :param program_id: SPL Token program account. :param freeze_authority: (optional) Account or multisig that can freeze token accounts. :param skip_confirmation: (optional) Option to skip transaction confirmation. :return: 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. """ mint_account = Account() token = Token(conn, mint_account.public_key(), program_id, payer) # Allocate memory for the account balance_needed = Token.get_min_balance_rent_for_exempt_for_mint(conn) # Construct transaction txn = Transaction() txn.add( sp.create_account( sp.CreateAccountParams( from_pubkey=payer.public_key(), new_account_pubkey=mint_account.public_key(), lamports=balance_needed, space=MINT_LAYOUT.sizeof(), program_id=program_id, ) ) ) txn.add( spl_token.initialize_mint( spl_token.InitializeMintParams( program_id=program_id, mint=mint_account.public_key(), decimals=decimals, mint_authority=mint_authority, freeze_authority=freeze_authority, ) ) ) # Send the two instructions conn.send_transaction( txn, payer, mint_account, opts=TxOpts(skip_confirmation=skip_confirmation, skip_preflight=True) ) return token
async def get_min_balance_rent_for_exempt_for_mint( conn: AsyncClient) -> int: """Get the minimum balance for the mint to be rent exempt. Args: conn: RPC connection to a solana cluster. Returns: Number of lamports required. """ resp = await conn.get_minimum_balance_for_rent_exemption( MINT_LAYOUT.sizeof()) return resp["result"]
def _create_mint_args( conn: Union[Client, AsyncClient], payer: Keypair, mint_authority: PublicKey, decimals: int, program_id: PublicKey, freeze_authority: Optional[PublicKey], skip_confirmation: bool, balance_needed: int, cls: Union[Type[Token], Type[AsyncToken]], ) -> Tuple[Union[Token, AsyncToken], Transaction, Keypair, Keypair, TxOpts]: mint_keypair = Keypair() token = cls(conn, mint_keypair.public_key, program_id, payer) # type: ignore # Construct transaction txn = Transaction() txn.add( sp.create_account( sp.CreateAccountParams( from_pubkey=payer.public_key, new_account_pubkey=mint_keypair.public_key, lamports=balance_needed, space=MINT_LAYOUT.sizeof(), program_id=program_id, ) ) ) txn.add( spl_token.initialize_mint( spl_token.InitializeMintParams( program_id=program_id, mint=mint_keypair.public_key, decimals=decimals, mint_authority=mint_authority, freeze_authority=freeze_authority, ) ) ) return token, txn, payer, mint_keypair, TxOpts(skip_confirmation=skip_confirmation, skip_preflight=True)