Solana 文档Solana 上的代币基础

创建代币账户

什么是代币账户

代币账户在 Solana 上为一个铸币和一个代币账户所有者存储代币。

Token Account Type
/// Account data.

#[repr(C)]

#[derive(Clone, Copy, Debug, Default, PartialEq)]

pub struct Account {

    /// The mint associated with this account

    pub mint: Pubkey,

    /// The owner of this account.

    pub owner: Pubkey,

    /// The amount of tokens this account holds.

    pub amount: u64,

    /// If `delegate` is `Some` then `delegated_amount` represents

    /// the amount authorized by the delegate

    pub delegate: COption<Pubkey>,

    /// The account's state

    pub state: AccountState,

    /// If `is_native.is_some`, this is a native token, and the value logs the

    /// rent-exempt reserve. An Account is required to be rent-exempt, so

    /// the value is used by the Processor to ensure that wrapped SOL

    /// accounts do not drop below this threshold.

    pub is_native: COption<u64>,

    /// The amount delegated

    pub delegated_amount: u64,

    /// Optional authority to close the account.

    pub close_authority: COption<Pubkey>,

}

这里，owner 指的是可以从 token account 中转移、销毁或委托代币的权限。该账户的程序所有者仍然是 Token Program 或 Token Extensions Program。

每个 token account 都与一个铸币严格绑定，这意味着该 token account 只能持有一种代币的单位，即由 token account 的 mint 字段标识的代币。

什么是关联代币账户

associated token account（ATA）是钱包和铸币的默认 token account。Associated Token Program 从钱包地址、代币程序地址和铸币地址派生 ATA 地址。

只有由 Associated Token Program 创建的 token account 才被称为 associated token account。

Associated Token Program 是一种在标准的、确定性地址创建 token account 的方法。生成的账户仍然是由 Token Program 或 Token Extensions Program 拥有的 token account，而不是由 Associated Token Program 拥有。

Associated Token Program 如 address.rs 所示派生 ATA 地址：

Associated Token Account Address Derivation
pub fn get_associated_token_address_and_bump_seed_internal(

    wallet_address: &Pubkey,

    token_mint_address: &Pubkey,

    program_id: &Pubkey,

    token_program_id: &Pubkey,

) -> (Pubkey, u8) {

    Pubkey::find_program_address(

        &[

            &wallet_address.to_bytes(), // Owner's public key

            &token_program_id.to_bytes(), // Token Program or Token Extension Program

            &token_mint_address.to_bytes(), // Token mint address

        ],

        program_id, // Associated Token Program ID

    )

}

对于任何钱包、代币程序和铸币的组合，都只有一个 ATA 地址。Associated Token Program 在该地址创建一个标准 token account，生成的账户仍然使用由 Token Program 或 Token Extensions Program 定义的 Account 类型。

如何创建关联代币账户

创建关联代币账户使用关联代币程序的 Create 或 CreateIdempotent 指令。关联代币程序会推导出 ATA 地址，在该 ATA 地址创建账户，并将该账户初始化为由 Token Program 或 Token Extensions Program 拥有的代币账户。

推荐

对于大多数应用程序，应通过关联代币程序创建代币账户，而不是直接调用系统程序和代币程序指令来创建。关联代币账户使用从所有者、代币程序和铸币厂推导出的确定性地址，这使得钱包和应用程序更容易找到给定铸币厂的默认代币账户。

源代码参考

项目描述源代码
Create在推导出的 ATA 地址创建关联代币账户。源代码
CreateIdempotent创建关联代币账户，但如果同一所有者和铸币厂的 ATA 已存在，仍然会成功执行。源代码
process_create_associated_token_account推导 ATA 地址并使用 create_pda_account 加上对所选代币程序的 CPI 来初始化代币账户。当所选程序为 Token Extensions Program 时，ATA 处理器还会初始化不可变所有者扩展。源代码
create_pda_accountprocess_create_associated_token_account 使用的辅助函数，通过对系统程序的 CPI 来创建 PDA 账户。源代码

Typescript

下面的 Kit 示例展示了使用 @solana/kit 的推荐方法。使用 @solana/web3.js 的旧版示例仅供参考。

Kit

import { generateKeyPairSigner } from "@solana/kit";

import { createLocalClient } from "@solana/kit-client-rpc";

import {

  associatedTokenProgram,

  findAssociatedTokenPda,

  tokenProgram,

  TOKEN_PROGRAM_ADDRESS

} from "@solana-program/token";



const client = await createLocalClient()

  .use(tokenProgram())

  .use(associatedTokenProgram());





const result = await client.associatedToken.instructions

  .createAssociatedToken({

    payer: client.payer, // Account funding account creation.

    mint: mint.address, // Mint for the token this account holds.

    owner: client.payer.address // Account that owns the token account.

  })

  .sendTransaction();



const [associatedTokenAddress] = await findAssociatedTokenPda({

  mint: mint.address,

  owner: client.payer.address,

  tokenProgram: TOKEN_PROGRAM_ADDRESS

});



const tokenAccountData = await client.token.accounts.token.fetch(

  associatedTokenAddress

);



console.log("Mint Address:", mint.address);

console.log("\nAssociated Token Account Address:", associatedTokenAddress);

console.log("Associated Token Account:", tokenAccountData.data);

console.log("\nTransaction Signature:", result.context.signature);
Console
Click to execute the code.

Web3.js

import { Connection, Keypair, LAMPORTS_PER_SOL } from "@solana/web3.js";

import {

  createAssociatedTokenAccount,

  createMint,

  getAccount,

  TOKEN_PROGRAM_ID

} from "@solana/spl-token";





const associatedTokenAccount = await createAssociatedTokenAccount(

  connection, // Connection to the local validator.

  feePayer, // Account funding account creation.

  mintPubkey, // Mint for the token this account holds.

  feePayer.publicKey, // Account that owns the token account.

  {

    commitment: "confirmed" // Confirmation options for the transaction.

  },

  TOKEN_PROGRAM_ID // Token program to invoke.

);



const tokenAccountData = await getAccount(

  connection,

  associatedTokenAccount,

  "confirmed",

  TOKEN_PROGRAM_ID

);



console.log("Mint Address:", mintPubkey.toBase58());

console.log(

  "\nAssociated Token Account Address:",

  associatedTokenAccount.toBase58()

);

console.log("Associated Token Account:", tokenAccountData);
Console
Click to execute the code.

Rust

Rust
use anyhow::Result;

use solana_client::nonblocking::rpc_client::RpcClient;

use solana_commitment_config::CommitmentConfig;

use solana_sdk::{

    program_pack::Pack,

    signature::{Keypair, Signer},

    transaction::Transaction,

};

use solana_system_interface::instruction::create_account;

use spl_associated_token_account_interface::{

    address::get_associated_token_address, instruction::create_associated_token_account,

};

use spl_token_interface::{

    id as token_program_id,

    instruction::initialize_mint,

    state::{Account, Mint},

};



#[tokio::main]

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

    let client = RpcClient::new_with_commitment(

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

        CommitmentConfig::confirmed(),

    );





    let transaction = Transaction::new_signed_with_payer(

        &[

            create_associated_token_account(

                &fee_payer.pubkey(), // Account funding account creation.

                &fee_payer.pubkey(), // Account that owns the token account.

                &mint.pubkey(), // Mint for the token this account holds.

                &token_program_id(), // Token program that owns the account.

            ),

        ],

        Some(&fee_payer.pubkey()),

        &[&fee_payer],

        latest_blockhash,

    );



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

    let associated_token_account = get_associated_token_address(&fee_payer.pubkey(), &mint.pubkey());

    let token_account = client.get_account(&associated_token_account).await?;

    let token_data = Account::unpack(&token_account.data)?;



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

    println!(

        "\nAssociated Token Account Address: {}",

        associated_token_account

    );

    println!("Associated Token Account: {:#?}", token_data);

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



    Ok(())

}
Console
Click to execute the code.

Python

Python
#!/usr/bin/env python3



import asyncio

import json

from solana.rpc.async_api import AsyncClient

from solders.keypair import Keypair

from solders.message import Message

from solders.pubkey import Pubkey

from solders.system_program import create_account, CreateAccountParams

from solders.transaction import Transaction

from spl.token.async_client import AsyncToken

from spl.token.instructions import (

    create_associated_token_account,

    get_associated_token_address,

    initialize_mint,

    InitializeMintParams,

)

from spl.token.constants import MINT_LEN, TOKEN_PROGRAM_ID



async def main():

    rpc = AsyncClient("http://localhost:8899")



    fee_payer = Keypair()

    owner = Keypair()



    async with rpc:



        create_associated_token_account_instruction = create_associated_token_account(

            payer=fee_payer.pubkey(),  # Account funding account creation.

            owner=owner.pubkey(),  # Account that owns the token account.

            mint=mint.pubkey(),  # Mint for the token this account holds.

            token_program_id=TOKEN_PROGRAM_ID,  # Token program that owns the new token account.

        )

        latest_blockhash = await rpc.get_latest_blockhash()

        transaction = Transaction(

            [fee_payer],

            Message([create_associated_token_account_instruction], fee_payer.pubkey()),

            latest_blockhash.value.blockhash,

        )

        result = await rpc.send_transaction(transaction)



        token_account_info = await token.get_account_info(associated_token_account)

        token_account = {

            key: str(value) if isinstance(value, Pubkey) else value

            for key, value in token_account_info._asdict().items()

        }



        print("Mint Address:", mint.pubkey())

        print("\nToken Account Address:", associated_token_account)

        print("Token Account:")

        print(json.dumps(token_account, indent=2))

        print("\nTransaction Signature:", result.value)



if __name__ == "__main__":

    asyncio.run(main())
Console
Click to execute the code.

如何创建 Token Account

创建 token account 需要两个指令:

  1. System Program 的 CreateAccount 指令创建一个新的免 rent 账户,并将 Token Program 指定为新账户的程序所有者。
  2. Token Program 的 InitializeAccount、InitializeAccount2 或 InitializeAccount3 指令为铸币和所有者初始化新账户。

在同一个交易中包含 CreateAccount 指令和 token account 初始化指令。

在 token account 初始化期间,Token Program 会检查该账户是否尚未初始化且已免 rent。

下面的部分展示了如何通过直接调用 System Program 和 Token Program 指令来创建 token account。对于大多数应用程序,请使用 Associated Token Program 代替。仅在您有特定原因不使用 associated token account 或需要通过从您自己的 Solana 程序向 System Program 和 Token Program 指令发起 CPI 来创建自定义 PDA token account 时,才使用直接的 System Program 和 Token Program 调用。

源代码参考

项目描述Token ProgramToken Extensions Program
Account存储在每个 token account 中的基本 token account 字段。源代码源代码
InitializeAccount一个 token account 初始化指令,期望在其账户列表中包含所有者和 rent sysvar 账户。源代码源代码
InitializeAccount2一个 token account 初始化指令,在 instruction data 中传递所有者而非在账户列表中传递。源代码源代码
InitializeAccount3一个 token account 初始化指令,在 instruction data 中传递所有者且不需要 rent sysvar 账户。源代码源代码
_process_initialize_accounttoken account 初始化的共享处理器逻辑。源代码源代码
process_initialize_accountInitializeAccount 的公共处理器。源代码源代码
process_initialize_account2InitializeAccount2 的公共处理器。源代码源代码
process_initialize_account3InitializeAccount3 的公共处理器。源代码源代码

Typescript

以下 Kit 示例展示了使用 @solana/kit 的推荐方法。同时提供了使用 @solana/web3.js 的传统示例以供参考。

Kit

import { generateKeyPairSigner } from "@solana/kit";

import { createLocalClient } from "@solana/kit-client-rpc";

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

import {

  getTokenSize,

  tokenProgram,

  TOKEN_PROGRAM_ADDRESS

} from "@solana-program/token";



const client = await createLocalClient()

  .use(systemProgram())

  .use(tokenProgram());





const result = await client.sendTransaction([

  client.system.instructions.createAccount({

    newAccount: tokenAccount, // New token account to create.

    lamports: rent, // Lamports funding the new account rent.

    space, // Account size in bytes.

    programAddress: TOKEN_PROGRAM_ADDRESS // Program that owns the new account.

  }),

  client.token.instructions.initializeAccount({

    account: tokenAccount.address, // Token account to initialize.

    mint: mint.address, // Mint for the token this account holds.

    owner: client.payer.address // Account that owns the token account.

  })

]);



const tokenAccountData = await client.token.accounts.token.fetch(

  tokenAccount.address

);



console.log("Mint Address:", mint.address);

console.log("\nToken Account Address:", tokenAccount.address);

console.log("Token Account:", tokenAccountData.data);

console.log("\nTransaction Signature:", result.context.signature);
Console
Click to execute the code.

Web3.js

import { Connection, Keypair, LAMPORTS_PER_SOL } from "@solana/web3.js";

import {

  createAccount,

  createMint,

  getAccount,

  TOKEN_PROGRAM_ID

} from "@solana/spl-token";





const tokenAccount = await createAccount(

  connection, // Connection to the local validator.

  feePayer, // Account paying transaction fees.

  mintPubkey, // Mint for the token this account holds.

  feePayer.publicKey, // Account that owns the token account.

  Keypair.generate(), // New token account to create.

  {

    commitment: "confirmed" // Confirmation options for the transaction.

  },

  TOKEN_PROGRAM_ID // Token program to invoke.

);



const tokenAccountData = await getAccount(

  connection,

  tokenAccount,

  "confirmed",

  TOKEN_PROGRAM_ID

);



console.log("Mint Address:", mintPubkey.toBase58());

console.log("\nToken Account Address:", tokenAccount.toBase58());

console.log("Token Account:", tokenAccountData);
Console
Click to execute the code.

Rust

Rust
use anyhow::Result;

use solana_client::nonblocking::rpc_client::RpcClient;

use solana_commitment_config::CommitmentConfig;

use solana_sdk::{

    program_pack::Pack,

    signature::{Keypair, Signer},

    transaction::Transaction,

};

use solana_system_interface::instruction::create_account;

use spl_token_interface::{

    id as token_program_id,

    instruction::{initialize_account, initialize_mint},

    state::{Account, Mint},

};



#[tokio::main]

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

    let client = RpcClient::new_with_commitment(

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

        CommitmentConfig::confirmed(),

    );





    let token_account = Keypair::new();

    let token_account_rent = client

        .get_minimum_balance_for_rent_exemption(Account::LEN)

        .await?;



    let transaction = Transaction::new_signed_with_payer(

        &[

            create_account(

                &fee_payer.pubkey(), // Account funding account creation.

                &token_account.pubkey(), // New token account to create.

                token_account_rent, // Lamports funding the new account rent.

                Account::LEN as u64, // Account size in bytes.

                &token_program_id(), // Program that owns the new account.

            ),

            initialize_account(

                &token_program_id(),

                &token_account.pubkey(), // Token account to initialize.

                &mint.pubkey(), // Mint for the token this account holds.

                &fee_payer.pubkey(), // Account that owns the token account.

            )?,

        ],

        Some(&fee_payer.pubkey()),

        &[&fee_payer, &token_account],

        latest_blockhash,

    );



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

    let token_account_data = client.get_account(&token_account.pubkey()).await?;

    let token_data = Account::unpack(&token_account_data.data)?;



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

    println!("\nToken Account Address: {}", token_account.pubkey());

    println!("Token Account: {:#?}", token_data);

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



    Ok(())

}
Console
Click to execute the code.

Python

Python
#!/usr/bin/env python3



import asyncio

import json

from solana.rpc.async_api import AsyncClient

from solders.keypair import Keypair

from solders.message import Message

from solders.pubkey import Pubkey

from solders.system_program import create_account, CreateAccountParams

from solders.transaction import Transaction

from spl.token.async_client import AsyncToken

from spl.token.instructions import (

    initialize_account,

    InitializeAccountParams,

    initialize_mint,

    InitializeMintParams,

)

from spl.token.constants import ACCOUNT_LEN, MINT_LEN, TOKEN_PROGRAM_ID



async def main():

    rpc = AsyncClient("http://localhost:8899")



    async with rpc:



        token_account = Keypair()

        token_account_rent = (await rpc.get_minimum_balance_for_rent_exemption(ACCOUNT_LEN)).value



        create_token_account_instructions = [

            create_account(

                CreateAccountParams(

                    from_pubkey=fee_payer.pubkey(),  # Account funding account creation.

                    to_pubkey=token_account.pubkey(),  # New token account to create.

                    lamports=token_account_rent,  # Lamports funding the new account rent.

                    space=ACCOUNT_LEN,  # Account size in bytes.

                    owner=TOKEN_PROGRAM_ID,  # Program that owns the new token account.

                )

            ),

            initialize_account(

                InitializeAccountParams(

                    program_id=TOKEN_PROGRAM_ID,  # Token program to invoke.

                    account=token_account.pubkey(),  # Token account to initialize.

                    mint=mint.pubkey(),  # Mint for the token this account holds.

                    owner=fee_payer.pubkey(),  # Account that owns the token account.

                )

            ),

        ]

        latest_blockhash = await rpc.get_latest_blockhash()

        transaction = Transaction(

            [fee_payer, token_account],

            Message(create_token_account_instructions, fee_payer.pubkey()),

            latest_blockhash.value.blockhash,

        )

        result = await rpc.send_transaction(transaction)



        token_account_info = await token.get_account_info(token_account.pubkey())

        token_account_data = {

            key: str(value) if isinstance(value, Pubkey) else value

            for key, value in token_account_info._asdict().items()

        }



        print("Mint Address:", mint.pubkey())

        print("\nToken Account Address:", token_account.pubkey())

        print("Token Account:")

        print(json.dumps(token_account_data, indent=2))

        print("\nTransaction Signature:", result.value)



if __name__ == "__main__":

    asyncio.run(main())
Console
Click to execute the code.

Is this page helpful?

上一页

创建代币铸造账户

下一页

铸造 Token

Table of Contents

Edit Page

管理者

©️ 2026 Solana 基金会版权所有
Solana
取得联系