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)