Τεκμηρίωση SolanaTokens στο SolanaΒασικά στοιχεία

Έκδοση Tokens

Πώς να Εκδώσετε Tokens

Η έκδοση tokens αναφέρεται στη διαδικασία δημιουργίας νέων μονάδων ενός token καλώντας την εντολή MintTo σε ένα token program. Μόνο η διεύθυνση που έχει οριστεί ως mint authority στο mint account μπορεί να εκδώσει νέα tokens. Η εντολή απαιτεί επίσης την ύπαρξη ενός token account ως προορισμό για τα νεοεκδοθέντα tokens.

Το Token Program και το Token Extension Program μοιράζονται παρόμοιες υλοποιήσεις για την επίτευξη της ίδιας λειτουργικότητας.

Typescript

import {

  airdropFactory,

  appendTransactionMessageInstructions,

  createSolanaRpc,

  createSolanaRpcSubscriptions,

  createTransactionMessage,

  generateKeyPairSigner,

  getSignatureFromTransaction,

  lamports,

  pipe,

  sendAndConfirmTransactionFactory,

  setTransactionMessageFeePayerSigner,

  setTransactionMessageLifetimeUsingBlockhash,

  signTransactionMessageWithSigners

} from "@solana/kit";

import { getCreateAccountInstruction } from "@solana-program/system";

import {

  getCreateAssociatedTokenInstructionAsync,

  getInitializeMintInstruction,

  getMintSize,

  TOKEN_2022_PROGRAM_ADDRESS,

  findAssociatedTokenPda,

  getMintToInstruction

} from "@solana-program/token-2022";



// Create Connection, local validator in this example

const rpc = createSolanaRpc("http://127.0.0.1:8899");

const rpcSubscriptions = createSolanaRpcSubscriptions("ws://localhost:8900");



// Generate keypairs for fee payer

const feePayer = await generateKeyPairSigner();



// Fund fee payer

await airdropFactory({ rpc, rpcSubscriptions })({

  recipientAddress: feePayer.address,

  lamports: lamports(1_000_000_000n),

  commitment: "confirmed"

});



// Generate keypair to use as address of mint

const mint = await generateKeyPairSigner();



// Get default mint account size (in bytes), no extensions enabled

const space = BigInt(getMintSize());



// Get minimum balance for rent exemption

const rent = await rpc.getMinimumBalanceForRentExemption(space).send();



// Get latest blockhash to include in transaction

const { value: latestBlockhash } = await rpc.getLatestBlockhash().send();



// Instruction to create new account for mint (token 2022 program)

// Invokes the system program

const createAccountInstruction = getCreateAccountInstruction({

  payer: feePayer,

  newAccount: mint,

  lamports: rent,

  space,

  programAddress: TOKEN_2022_PROGRAM_ADDRESS

});



// Instruction to initialize mint account data

// Invokes the token 2022 program

const initializeMintInstruction = getInitializeMintInstruction({

  mint: mint.address,

  decimals: 2,

  mintAuthority: feePayer.address

});



// Create instruction to create the associated token account

const createAtaInstruction = await getCreateAssociatedTokenInstructionAsync({

  payer: feePayer,

  mint: mint.address,

  owner: feePayer.address

});



const instructions = [

  createAccountInstruction,

  initializeMintInstruction,

  createAtaInstruction

];



// Create transaction message

const transactionMessage = pipe(

  createTransactionMessage({ version: 0 }),

  (tx) => setTransactionMessageFeePayerSigner(feePayer, tx),

  (tx) => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, tx),

  (tx) => appendTransactionMessageInstructions(instructions, tx)

);



// Sign transaction message with all required signers

const signedTransaction =

  await signTransactionMessageWithSigners(transactionMessage);



// Send and confirm transaction

await sendAndConfirmTransactionFactory({ rpc, rpcSubscriptions })(

  signedTransaction,

  { commitment: "confirmed" }

);



// Get transaction signature

const transactionSignature = getSignatureFromTransaction(signedTransaction);



// Use findAssociatedTokenPda to derive the ATA address

const [associatedTokenAddress] = await findAssociatedTokenPda({

  mint: mint.address,

  owner: feePayer.address,

  tokenProgram: TOKEN_2022_PROGRAM_ADDRESS

});



console.log(

  "Associated Token Account Address: ",

  associatedTokenAddress.toString()

);



// Create instruction to mint tokens

const mintToInstruction = getMintToInstruction({

  mint: mint.address,

  token: associatedTokenAddress,

  mintAuthority: feePayer.address,

  amount: 100n // 1.00 tokens with 2 decimals

});



// Create transaction message for minting tokens

const mintTxMessage = pipe(

  createTransactionMessage({ version: 0 }),

  (tx) => setTransactionMessageFeePayerSigner(feePayer, tx),

  (tx) => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, tx),

  (tx) => appendTransactionMessageInstructions([mintToInstruction], tx)

);



// Sign transaction message with all required signers

const signedMintTx = await signTransactionMessageWithSigners(mintTxMessage);



// Send and confirm transaction

await sendAndConfirmTransactionFactory({ rpc, rpcSubscriptions })(

  signedMintTx,

  { commitment: "confirmed" }

);



// Get transaction signature

const mintTxSignature = getSignatureFromTransaction(signedMintTx);



console.log("Successfully minted 1.00 tokens to the associated token account");

console.log("Transaction Signature:", mintTxSignature);
Console
Click to execute the code.

Rust

use anyhow::Result;

use solana_client::rpc_client::RpcClient;

use solana_sdk::{

    commitment_config::CommitmentConfig,

    program_pack::Pack,

    signature::{Keypair, Signer},

    system_instruction::create_account,

    transaction::Transaction,

};

use spl_associated_token_account::{

    get_associated_token_address_with_program_id, instruction::create_associated_token_account,

};

use spl_token_2022::{

    id as token_2022_program_id,

    instruction::{initialize_mint, mint_to},

    state::Mint,

};



fn main() -> Result<()> {

    // Create connection to local validator

    let client = RpcClient::new_with_commitment(

        String::from("http://127.0.0.1:8899"),

        CommitmentConfig::confirmed(),

    );

    let recent_blockhash = client.get_latest_blockhash()?;



    // Generate a new keypair for the fee payer

    let fee_payer = Keypair::new();



    // Airdrop 1 SOL to fee payer

    let airdrop_signature = client.request_airdrop(&fee_payer.pubkey(), 1_000_000_000)?;

    client.confirm_transaction(&airdrop_signature)?;



    loop {

        let confirmed = client.confirm_transaction(&airdrop_signature)?;

        if confirmed {

            break;

        }

    }



    // Generate keypair to use as address of mint

    let mint = Keypair::new();



    // Get default mint account size (in bytes), no extensions enabled

    let mint_space = Mint::LEN;

    let mint_rent = client.get_minimum_balance_for_rent_exemption(mint_space)?;



    // Instruction to create new account for mint (token 2022 program)

    let create_account_instruction = create_account(

        &fee_payer.pubkey(),      // payer

        &mint.pubkey(),           // new account (mint)

        mint_rent,                // lamports

        mint_space as u64,        // space

        &token_2022_program_id(), // program id

    );



    // Instruction to initialize mint account data

    let initialize_mint_instruction = initialize_mint(

        &token_2022_program_id(),

        &mint.pubkey(),            // mint

        &fee_payer.pubkey(),       // mint authority

        Some(&fee_payer.pubkey()), // freeze authority

        2,                         // decimals

    )?;



    // Calculate the associated token account address for fee_payer

    let associated_token_account = get_associated_token_address_with_program_id(

        &fee_payer.pubkey(),      // owner

        &mint.pubkey(),           // mint

        &token_2022_program_id(), // program_id

    );



    // Instruction to create associated token account

    let create_ata_instruction = create_associated_token_account(

        &fee_payer.pubkey(),      // funding address

        &fee_payer.pubkey(),      // wallet address

        &mint.pubkey(),           // mint address

        &token_2022_program_id(), // program id

    );



    // Create transaction and add instructions

    let transaction = Transaction::new_signed_with_payer(

        &[

            create_account_instruction,

            initialize_mint_instruction,

            create_ata_instruction,

        ],

        Some(&fee_payer.pubkey()),

        &[&fee_payer, &mint],

        recent_blockhash,

    );



    // Send and confirm transaction

    let transaction_signature = client.send_and_confirm_transaction(&transaction)?;



    println!("Mint Address: {}", mint.pubkey());

    println!(

        "Associated Token Account Address: {}",

        associated_token_account

    );

    println!("Transaction Signature: {}", transaction_signature);



    // Get the latest blockhash for the mint transaction

    let recent_blockhash = client.get_latest_blockhash()?;



    // Amount of tokens to mint (1.00 tokens with 2 decimals)

    let amount = 100;



    // Create mint_to instruction to mint tokens to the associated token account

    let mint_to_instruction = mint_to(

        &token_2022_program_id(),

        &mint.pubkey(),            // mint

        &associated_token_account, // destination

        &fee_payer.pubkey(),       // authority

        &[&fee_payer.pubkey()],    // signer

        amount,                    // amount

    )?;



    // Create transaction for minting tokens

    let transaction = Transaction::new_signed_with_payer(

        &[mint_to_instruction],

        Some(&fee_payer.pubkey()),

        &[&fee_payer],

        recent_blockhash,

    );



    // Send and confirm transaction

    let transaction_signature = client.send_and_confirm_transaction(&transaction)?;



    println!("Successfully minted {} tokens to the associated token account", amount);

    println!("Transaction Signature: {}", transaction_signature);



    Ok(())

}
Console
Click to execute the code.

Is this page helpful?

Προηγούμενο

Δημιουργία ενός Token Account

Επόμενο

Μεταφορά Tokens

Πίνακας Περιεχομένων

Επεξεργασία Σελίδας

Διαχειρίζεται από

© 2025 Ίδρυμα Solana. Με επιφύλαξη παντός δικαιώματος.
Solana
Συνδεθείτε
© 2025 Ίδρυμα Solana. Με επιφύλαξη παντός δικαιώματος.