使用 Anchor 和 QuickNode 在 Solana 上创建NFT： 2024 版指南

于 2024-09-28 15:15:31 发布
阅读量483 收藏 10
点赞数 6
文章标签： qt 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2402_87505616/article/details/142616191
版权

gg

欢迎来到本教程。今天，我们将使用 Solana Playground、QuickNode RPC 和一个 IPFS 服务，在 Anchor/Rust 中创建一个 Solana 程序，以直接在链上铸造 NFT。

作为预备步骤，我们将在去中心化存储服务中准备我们的 NFT 图像和元数据。我们将使用 QuickNode IPFS，这是一个 IPFS 存储服务，适用于需要快速、高可用访问和高级功能的解决方案。

让我们上传将成为我们 NFT 的图像。在 QuickNode 仪表板上，转到 IPFS 然后是文件，你可以拖放你的图像。

让我们复制出现在我们上传的文件名旁边的内容标识符 (CID)。然后我们将其附加到地址 quicknode.myfilebase.com/ipfs/ 以获得我们将在元数据中使用的 URL。测试此 URL 以确保一切正确是很重要的。

为我们的 NFT 创建元数据

为此，我们将基于 Metaplex 为 Solana 上的 NFT 元数据创建的标准。你可以访问 Metaplex 文档 了解更多信息。

我们的元数据将是一个 JSON 文件，包含我们为 NFT 选择的参数 Name、Symbol 和 Description。

{  
    "name": "Name",  
    "symbol": "symbol",  
    "description": "your description",  
    "image": "quicknode.myfilebase.com/ipfs/CID",  
    "attributes": [  
        {  
            "trait_type": "type",  
            "value": "value"  
        }  
    ],  
    "properties": {  
        "creators": [  
            {  
                "address": "creators's wallet address",  
                "share": royalty  
            }  
        ],  
        "files": [  
            {  
                "type": "image/png",  
                "uri": "ipfs://CID"  
            }  
        ]  
    },  
    "collection": {  
        "name": "name",  
        "family": "family"  
    }  
}

一旦我们的 .json 文件准备好，我们将返回 QuickNode 的文件选项卡并像处理图像文件一样拖放它。现在我们已经准备好继续。

设置 Solana Playground

我们将前往 Solana Playground 并通过创建一个新钱包进行连接。

Solana Playground

点击显示“not connected”的地方，然后保存密钥对并继续。

保存密钥对

在这里我们可以看到创建的钱包地址。

创建的钱包地址

创建一个新项目，给它命名，选择 Anchor (Rust) 并创建。

创建的 Anchor 项目

注意：我们将需要大约 10 个 DevNet 的 Solana 来部署合约。要为我们的钱包充值，我们必须在 Sol Faucet 中输入我们刚刚创建的钱包地址，该网站允许我们每 24 小时充值 3 个 Solana。这意味着我们需要几天时间来完成充值。作为替代方案，我们建议使用其他钱包地址和 VPN 来加快进程。_

现在是时候配置 solpg 以使用 QuickNode RPC 在 Solana DevNet 上工作了。点击设置选项卡，然后点击端点选项卡。

设置 Solana Playground

选择自定义并粘贴你的 QuickNode 私有 RPC 用于 Solana DevNet。

自定义 RPC

完成后，回到我们新创建的项目中，我们将删除不需要的代码，并保留来自 anchor_lang 的主要导入、程序 id 的默认声明以及程序和派生账户属性的声明。

应该看起来像这样：

use anchor_lang::prelude::*;

declare_id!("11111111111111111111111111111111");

#[program]

#[derive(Accounts)]

现在，我们将导入所有这些库和必要的元素。这些库具有在 Solana 上铸造新 NFT 所需的所有标准功能，我们将在过程中需要每一个。

use anchor_spl::associated_token::AssociatedToken;
use anchor_spl::metadata::{
    create_master_edition_v3, create_metadata_accounts_v3, CreateMasterEditionV3,
    CreateMetadataAccountsV3, Metadata,
};
use anchor_spl::token::{mint_to, Mint, MintTo, Token, TokenAccount};
use mpl_token_metadata::types::{Collection, Creator, DataV2};

现在你的代码应该看起来像这样：

use anchor_lang::prelude::*;
use anchor_spl::associated_token::AssociatedToken;
use anchor_spl::metadata::{
    create_master_edition_v3, create_metadata_accounts_v3, CreateMasterEditionV3,
    CreateMetadataAccountsV3, Metadata,
};
use anchor_spl::token::{mint_to, Mint, MintTo, Token, TokenAccount};
use mpl_token_metadata::types::{Collection, Creator, DataV2};

declare_id!("11111111111111111111111111111111");

#[program]

#[derive(Accounts)]

在 [derive(Accounts)] 属性下，我们将定义一个包含与程序交互所需的所有账户的结构。

我们将定义一个名为 CreateNFT 的公共结构。它将有一个参数 'info，表示在使用此结构作为上下文的指令执行期间它将保留在内存中。

我们在结构中定义的第一个账户将是 authority。我们将其定义为类型为 Signer 的公共账户，具有 'info 类型的生命周期。我们在此结构中定义的所有账户都将是公共类型并具有此生命周期。

#[derive(Accounts)]
pub struct CreateNFT<'info> {
   pub authority: Signer<'info>,
}

我们将为此账户定义一个属性。放置以下行，并在括号内放置 mut 这个词，表示可变。这意味着 NFT 的权限将来可以更改。

#[derive(Accounts)]
pub struct CreateNFT<'info> {
  #[account(mut)]
  pub authority: Signer<'info>,
}

同样，我们将定义 payer 账户及其相应的可变属性 mut。

#[derive(Accounts)]
pub struct CreateNFT<'info> {
  #[account(mut)]
  pub authority: Signer<'info>,
  #[account(mut)]
  pub payer: Signer<'info>,
}

现在我们声明 mint 账户，类型为 Account，它将携带类型为 mint 的结构。我们已经从 anchor_spl 代币库中导入了这个结构。

#[derive(Accounts)]
pub struct CreateNFT<'info> {
  #[account(mut)]
  pub authority: Signer<'info>,
  #[account(mut)]
  pub payer: Signer<'info>,
  pub mint: Account<'info, Mint>,
}

我们的 mint 账户将携带以下参数：

  • init: 因为我们必须初始化它
  • payer 账户作为支付初始化的账户
  • 内部 mint 结构：小数位为 0，因为它是不可替代代币 (NFT)
  • 然后我们将 authority 账户作为 mint 结构的权限传递
  • freeze_authority 参数同样
#[derive(Accounts)]  
pub struct CreateNFT<'info> {  
  #[account(mut)]  
  pub authority: Signer<'info>,  
  #[account(mut)]  
  pub payer: Signer<'info>,  
  #[account(   
    init,  
    payer = payer,   
    mint::decimals = 0,  
    mint::authority = authority,  
    mint::freeze_authority = authority,  
    )]  
  pub mint: Account<'info, Mint>,  
}

现在我们设置种子来创建派生地址，首先将以字节形式携带单词 mint 和 id 参数的字节形式。

#[derive(Accounts)]  
pub struct CreateNFT<'info> {  
  #[account(mut)]  
  pub authority: Signer<'info>,  
  #[account(mut)]  
  pub payer: Signer<'info>,  
  #[account(   
    init,  
    payer = payer,   
    mint::decimals = 0,  
    mint::authority = authority,  
    mint::freeze_authority = authority,  
    seeds = ["mint".as_bytes(), id.to_le_bytes().as_ref()],   
    bump,  
    )]  
  pub mint: Account<'info, Mint>,  
}

我们将从合约中创建的指令中获取此 id 参数，并在调用时接收它以铸造 NFT。因此，我们必须声明此属性，将从以下指令中获取。

#[derive(Accounts)]  
#[instruction(id: u64)]  
  
pub struct CreateNFT<'info> {  
  #[account(mut)]  
  pub authority: Signer<'info>,  
  #[account(mut)]  
  pub payer: Signer<'info>,  
  #[account(   
    init,  
    payer = payer,   
    mint::decimals = 0,  
    mint::authority = authority,  
    mint::freeze_authority = authority,  
    seeds = ["mint".as_bytes(), id.to_le_bytes().as_ref()],   
    bump,  
    )]  
  pub mint: Account<'info, Mint>,  
}

现在我们将创建 token_account，它将携带一种代币账户类型的结构，允许我们将铸造账户与将接收铸造 NFT 的账户关联起来。

#[derive(Accounts)]  
#[instruction(id: u64)]  
  
pub struct CreateNFT<'info> {  
  #[account(mut)]  
  pub authority: Signer<'info>,  
  #[account(mut)]  
  pub payer: Signer<'info>,  
  #[account(   
    init,  
    payer = payer,   
    mint::decimals = 0,  
    mint::authority = authority,  
    mint::freeze_authority = authority,  
    seeds = ["mint".as_bytes(), id.to_le_bytes().as_ref()],   
    bump,  
    )]  
  pub mint: Account<'info, Mint>,  
  pub token_account: Account<'info, TokenAccount>,  
}

其参数将是 init_if_needed，即如果不存在将创建一个新账户。我们将发送 payer 作为我们的支付账户。对于 associated_token 结构中存在的 mint 参数，我们将发送铸造账户和支付账户作为权限。

#[derive(Accounts)]  
#[instruction(id: u64)]  
  
pub struct CreateNFT<'info> {  
  #[account(mut)]  
  pub authority: Signer<'info>,  
  #[account(mut)]  
  pub payer: Signer<'info>,  
  #[account(   
    init,  
    payer = payer,   
    mint::decimals = 0,  
    mint::authority = authority,  
    mint::freeze_authority = authority,  
    seeds = ["mint".as_bytes(), id.to_le_bytes().as_ref()],   
    bump,  
    )]  
  pub mint: Account<'info, Mint>,  
  #[account(  
        init_if_needed,  
        payer = payer,  
        associated_token::mint = mint,  
        associated_token::authority = payer,  
    )]  
  pub token_account: Account<'info, TokenAccount>,  
  
}

现在我们声明以下过程所需的账户：

  • associated_token_program：Anchor SPL 库程序，用于关联账户。
  • rent：Sysvar 类型程序，帮助确定租金成本。
  • system_program：Solana 的主要程序。
  • token_program：允许在 Solana 上创建代币的程序。
  • metadata_program：用于根据 Metaplex 标准将元数据关联到账户的程序。
#[derive(Accounts)]  
#[instruction(id: u64)]  
  
pub struct CreateNFT<'info> {  
  #[account(mut)]  
  pub authority: Signer<'info>,  
  #[account(mut)]  
  pub payer: Signer<'info>,  
  #[account(   
    init,  
    payer = payer,   
    mint::decimals = 0,  
    mint::authority = authority,  
    mint::freeze_authority = authority,  
    seeds = ["mint".as_bytes(), id.to_le_bytes().as_ref()],   
    bump,  
    )]  
  pub mint: Account<'info, Mint>,  
  #[account(  
        init_if_needed,  
        payer = payer,  
        associated_token::mint = mint,  
        associated_token::authority = payer,  
    )]  
   pub token_account: Account<'info, TokenAccount>,  
   pub associated_token_program: Program<'info, AssociatedToken>,  
   pub rent: Sysvar<'info, Rent>,  
   pub system_program: Program<'info, System>,  
   pub token_program: Program<'info, Token>,  
   pub metadata_program: Program<'info, Metadata>,  
}

最后，我们声明 UncheckedAccount 类型的账户，master_edition_account 和 nft_metadata。我们还必须添加带有 ///CHECK 的行，以通知编译器我们正在处理未经检查的账户类型。

#[derive(Accounts)]  
#[instruction(id: u64)]  
  
pub struct CreateNFT<'info> {  
  #[account(mut)]  
  pub authority: Signer<'info>,  
  #[account(mut)]  
  pub payer: Signer<'info>,  
  #[account(   
    init,  
    payer = payer,   
    mint::decimals = 0,  
    mint::authority = authority,  
    mint::freeze_authority = authority,  
    seeds = ["mint".as_bytes(), id.to_le_bytes().as_ref()],   
    bump,  
    )]  
  pub mint: Account<'info, Mint>,  
  #[account(  
        init_if_needed,  
        payer = payer,  
        associated_token::mint = mint,  
        associated_token::authority = payer,  
    )]  
   pub token_account: Account<'info, TokenAccount>,  
   pub associated_token_program: Program<'info, AssociatedToken>,  
   pub rent: Sysvar<'info, Rent>,  
   pub system_program: Program<'info, System>,  
   pub token_program: Program<'info, Token>,  
   pub metadata_program: Program<'info, Metadata>,  
   /// CHECK:  
   pub master_edition_account: UncheckedAccount<'info>,  
   /// CHECK:  
   pub nft_metadata: UncheckedAccount<'info>,  
}

master_edition_account 是必要的，以确保 Solana 网络上的代币通过将其与主版本账户关联来有效地是不可替代的。通过它可以创建更多的代币信息实例，所有这些实例都与这个唯一的账户关联，以创建不同类型的 NFT。

我们将为此账户定义以下参数：

  • 可变：其种子将按照文档要求精确定义如下。
  • Bump：我们必须放置这一行，因为这个 PDA 账户将由元数据程序生成。
#[derive(Accounts)]  
#[instruction(id: u64)]  
  
pub struct CreateNFT<'info> {  
  #[account(mut)]  
  pub authority: Signer<'info>,  
  #[account(mut)]  
  pub payer: Signer<'info>,  
  #[account(   
    init,  
    payer = payer,   
    mint::decimals = 0,  
    mint::authority = authority,  
    mint::freeze_authority = authority,  
    seeds = ["mint".as_bytes(), id.to_le_bytes().as_ref()],   
    bump,  
    )]  
  pub mint: Account<'info, Mint>,  
  #[account(  
        init_if_needed,  
        payer = payer,  
        associated_token::mint = mint,  
        associated_token::authority = payer,  
    )]  
   pub token_account: Account<'info, TokenAccount>,  
   pub associated_token_program: Program<'info, AssociatedToken>,  
   pub rent: Sysvar<'info, Rent>,  
   pub system_program: Program<'info, System>,  
   pub token_program: Program<'info, Token>,  
   pub metadata_program: Program<'info, Metadata>,  
   #[account(  
        mut,  
        seeds = [  
            b"metadata".as_ref(),  
            metadata_program.key().as_ref(),  
            mint.key().as_ref(),  
            b"edition".as_ref(),  
        ],  
        bump,  
        seeds::program = metadata_program.key()  
      )]    
   /// 检查:  
   pub master_edition_account: UncheckedAccount<'info>,  
   /// 检查:  
   pub nft_metadata: UncheckedAccount<'info>,  
}

对于 nft_metadata 账户，我们将设置以下参数，方式与 master_edition_account 类似。

#[derive(Accounts)]  
#[instruction(id: u64)]  
  
pub struct CreateNFT<'info> {  
  #[account(mut)]  
  pub authority: Signer<'info>,  
  #[account(mut)]  
  pub payer: Signer<'info>,  
  #[account(   
    init,  
    payer = payer,   
    mint::decimals = 0,  
    mint::authority = authority,  
    mint::freeze_authority = authority,  
    seeds = ["mint".as_bytes(), id.to_le_bytes().as_ref()],   
    bump,  
    )]  
  pub mint: Account<'info, Mint>,  
  #[account(  
        init_if_needed,  
        payer = payer,  
        associated_token::mint = mint,  
        associated_token::authority = payer,  
    )]  
   pub token_account: Account<'info, TokenAccount>,  
   pub associated_token_program: Program<'info, AssociatedToken>,  
   pub rent: Sysvar<'info, Rent>,  
   pub system_program: Program<'info, System>,  
   pub token_program: Program<'info, Token>,  
   pub metadata_program: Program<'info, Metadata>,  
   #[account(  
        mut,  
        seeds = [  
            b"metadata".as_ref(),  
            metadata_program.key().as_ref(),  
            mint.key().as_ref(),  
            b"edition".as_ref(),  
        ],  
        bump,  
        seeds::program = metadata_program.key()  
      )]  
  
   /// 检查:  
   pub master_edition_account: UncheckedAccount<'info>,  
   #[account(  
        mut,  
        seeds = [  
            b"metadata".as_ref(),  
            metadata_program.key().as_ref(),  
            mint.key().as_ref(),  
        ],  
        bump,  
        seeds::program = metadata_program.key()  
    )]  
   /// 检查:  
   pub nft_metadata: UncheckedAccount<'info>,  
}

有了我们的 CreateNFT 结构，我们将开始创建我们的程序。在程序属性下，我们创建公共模块 nft_program。

#[program]  
pub mod nft_program {}

我们使用以下指令导入整个父模块：

#[program]  
pub mod nft_program {  
 use super::*;  
}

我们将以下列方式创建公共函数 create_single_nft。

#[program]  
pub mod nft_program {  
 use super::*;  
 pub fn create_single_nft() -> Result<()> {  
}

然后我们将指定函数将接收的参数：

  • Context: 我们将在其中引入我们在创建 NFT 结构中创建的所有账户
  • NFT ID
  • 名称
  • 符号
  • URI
  • 价格
  • 数量
#[program]  
pub mod nft_program {  
 use super::*;  
 pub fn create_single_nft(  
 ctx: Context<CreateNFT>,  
 id: u64,  
 name: String,  
 symbol: String,  
 uri: String,  
 price: f32,  
 cant: u64,  
) -> Result<()> {  
}

我们的函数将按以下特定顺序调用以下 3 个函数：

  • 我们从 anchor_spl 代币库导入的 mint_to 函数
  • create_metadata_accounts_v3
  • create_master_edition_v3 从 anchor_spl 元数据库导入
#[program]  
pub mod nft_program {  
 use super::*;  
 pub fn create_single_nft(  
 ctx: Context<CreateNFT>,  
 id: u64,  
 name: String,  
 symbol: String,  
 uri: String,  
 price: f32,  
 cant: u64,  
) -> Result<()> {  
  mint_to()?;  
  create_metadata_accounts_v3()?;  
  create_master_edition_v3()?;  
}

如果我们查看 Rust 文档 中的 mint_to 函数，我们会看到它接收一个 CpiContext，其中包含一个在同一库中定义的 mint_to 结构类型和一个数量。

rust 文档 mint_to

CpiContext 用于我们的程序与网络上的其他程序交互。此上下文必须通过 new_with_signer() 函数定义，因为它需要一个种子来签署交易。

 mint_to(  
            CpiContext::new_with_signer(  
                ctx.accounts.token_program.to_account_info(),  
                MintTo {  
                    authority: ctx.accounts.authority.to_account_info(),  
                    to: ctx.accounts.token_account.to_account_info(),  
                    mint: ctx.accounts.mint.to_account_info(),  
  
                &[&seeds[..]],  
             ),

new_with_signer() 函数接收我们将与之交互的程序。此程序已在我们的 CreateNFT 结构中定义，因此我们通过上下文 ctx.account 代币程序访问它，并使用 to_account_info() 函数读取其地址。这是 Solana 上的代币创建程序。

new_with_signer() 函数的下一个参数，用于创建 CpiContext，将是 MintTo 账户数组。它将包含：

  • authority，也在我们的上下文中定义，我们通过 ctx.account_authority 访问它，也将其转换为账户信息
  • to，接收 NFT 的账户，这将是与代币 mint 账户关联的钱包 payer 的账户，或支付交易的账户
  • mint，网络上的代币身份

所有这些账户都来自我们已经创建的上下文。

最后，函数将接收形成我们 seeds 的字节列表。

此种子必须以前以以下方式声明：

  • 我们将作为参数接收的 id 转换为字节 id_bytes = id.to_le_bytes
  • 然后，我们将我们的 seeds 声明为一个数组，首先将字符串 "mint" 转换为字节
  • 我们的 id_bytes 变量转换为引用，并从我们的上下文中动态获取并引用的 mint 账户的 bump

这将是签署所有后续函数调用的种子。

 ) -> Result<()> {  
        let id_bytes = id.to_le_bytes();  
        let seeds = &["mint".as_bytes(),id_bytes.as_ref(),&[ctx.bumps.mint],  
        ];  
  
mint_to(  
            CpiContext::new_with_signer(  
                ctx.accounts.token_program.to_account_info(),  
                MintTo {  
                    authority: ctx.accounts.authority.to_account_info(),  
                    to: ctx.accounts.token_account.to_account_info(),  
                    mint: ctx.accounts.mint.to_account_info(),  
  
                &[&seeds[..]],  
             ),

现在让我们构建对 create_metadata_accounts_v3 函数的调用。这次，参数将是：

  • 再次使用 new_with_signer() 函数创建的 CpiContext
  • 一个 DataV2 结构
  • 以及我们将发送的两个布尔值，第一个设置为授权账户为相同的签名者，第二个使元数据可变
  • 最后，集合详细信息的单词 none

我们将首先使用来自我们上下文的元数据程序账户构建 CpiContext。这将是我们在此函数中将与之交互的程序。

然后，我们将发送 CreateMetadataAccountsV3 结构。使用以下参数，均从我们的 CreateNFT 结构中获取：

  • payer
  • mint 账户
  • NFT metadata 账户
  • 铸造和更新授权，将与授权账户一起使用
  • system_program 也在上下文中可用
  • rent
  • 最后，函数将接收我们已经创建并可用的 seeds
create_metadata_accounts_v3(  
            CpiContext::new_with_signer(  
                ctx.accounts.metadata_program.to_account_info(),  
                CreateMetadataAccountsV3 {  
                    payer: ctx.accounts.payer.to_account_info(),  
                    mint: ctx.accounts.mint.to_account_info(),  
                    metadata: ctx.accounts.nft_metadata.to_account_info(),  
                    mint_authority: ctx.accounts.authority.to_account_info(),  
                    update_authority: ctx.accounts.authority.to_account_info(),  
                    system_program: ctx.accounts.system_program.to_account_info(),  
                    rent: ctx.accounts.rent.to_account_info(),  
                },  
                &[&seeds[..]],

我们仍然需要填写 DataV2 结构的参数，这些参数将是：

  • name、symbol 和 URI 都将作为参数传递给我们的 create_single_nft 函数
  • seller_fee_basis_points 参数的值为 0
  • 参数 creators、collection 和 use 都设置为 none

我们将放置消息 msg，表示正在执行创建元数据账户的函数，我们的代码将如下所示：

  msg!("Run create metadata accounts v3");  
  
        create_metadata_accounts_v3(  
            CpiContext::new_with_signer(  
                ctx.accounts.metadata_program.to_account_info(),  
                CreateMetadataAccountsV3 {  
                    payer: ctx.accounts.payer.to_account_info(),  
                    mint: ctx.accounts.mint.to_account_info(),  
                    metadata: ctx.accounts.nft_metadata.to_account_info(),  
                    mint_authority: ctx.accounts.authority.to_account_info(),  
                    update_authority: ctx.accounts.authority.to_account_info(),  
                    system_program: ctx.accounts.system_program.to_account_info(),  
                    rent: ctx.accounts.rent.to_account_info(),  
                },  
                &[&seeds[..]],  
            ),  
            DataV2 {  
                name,  
                symbol,  
                uri,  
                seller_fee_basis_points: 0,  
                creators: None,  
                collection: None,  
                uses: None,  
            },  
            true,  
            true,  
            None,  
        )?;

我们还将以相同的方式调用 create_master_edition_v3 函数，使用 new_with_signer() 函数创建的 CpiContext，最大供应量为 1，方式如下 some(1)。

new_with_signer() 函数接收元数据程序作为程序，CreateMetadataAccountsV3 结构包含上下文中的所有这些账户：

  • edition 账户，payer 账户作为付款人，mint 账户，包含代币 metadata 的账户
  • mint_authority、update_authority、system_program、token_program 和 rent
  • 最后，我们放置我们的 seeds 进行签名。我们将放置消息 msg “Executing the create master edition function”，最后放置消息 msg “The NFT has been successfully created”，并用 ok 完成函数

我们的代码将如下所示：

  msg!("Run create master edition v3");  
  
        create_master_edition_v3(  
            CpiContext::new_with_signer(  
                ctx.accounts.metadata_program.to_account_info(),  
                CreateMasterEditionV3 {  
                    edition: ctx.accounts.master_edition_account.to_account_info(),  
                    payer: ctx.accounts.payer.to_account_info(),  
                    mint: ctx.accounts.mint.to_account_info(),  
                    metadata: ctx.accounts.nft_metadata.to_account_info(),  
                    mint_authority: ctx.accounts.authority.to_account_info(),  
                    update_authority: ctx.accounts.authority.to_account_info(),  
                    system_program: ctx.accounts.system_program.to_account_info(),  
                    token_program: ctx.accounts.token_program.to_account_info(),  
                    rent: ctx.accounts.rent.to_account_info(),  
                },  
                &[&seeds[..]],  
            ),  
      Some(1),  
          )?;  
  
          msg!("Minted NFT successfully");  
  
          Ok(())  
    }

这将是整个代码：

use anchor_lang::prelude::*;  
use anchor_spl::associated_token::AssociatedToken;  
use anchor_spl::metadata::{  
    create_master_edition_v3, create_metadata_accounts_v3, CreateMasterEditionV3,  
    CreateMetadataAccountsV3, Metadata,  
};  
use anchor_spl::token::{mint_to, Mint, MintTo, Token, TokenAccount};  
use mpl_token_metadata::types::{Collection, Creator, DataV2};  
  
declare_id!("nuvdhmYq5Z2Eg4nBi29Tu2VcbpE9nuiCQ68rkyAB3A1");  
  
#[program]  
pub mod nft_program {  
 use super::*;  
 pub fn create_single_nft(  
 ctx: Context<CreateNFT>,  
 id: u64,  
 name: String,  
 symbol: String,  
 uri: String,  
 price: f32,  
 cant: u64,  
) -> Result<()> {  
 msg!("Creating seeds");  
        let id_bytes = id.to_le_bytes();  
        let seeds = &["mint".as_bytes(),id_bytes.as_ref(),&[ctx.bumps.mint],  
        ];  
  
        msg!("Run mint_to");  
  
        mint_to(  
            CpiContext::new_with_signer(  
                ctx.accounts.token_program.to_account_info(),  
                MintTo {  
                    authority: ctx.accounts.authority.to_account_info(),  
                    to: ctx.accounts.token_account.to_account_info(),  
                    mint: ctx.accounts.mint.to_account_info(),  
                },  
                &[&seeds[..]],  
            ),  
            1, // 1 token  
        )?;  
  
        msg!("Run create metadata accounts v3");  
  
        create_metadata_accounts_v3(  
            CpiContext::new_with_signer(  
                ctx.accounts.metadata_program.to_account_info(),  
                CreateMetadataAccountsV3 {  
                    payer: ctx.accounts.payer.to_account_info(),  
                    mint: ctx.accounts.mint.to_account_info(),  
                    metadata: ctx.accounts.nft_metadata.to_account_info(),  
                    mint_authority: ctx.accounts.authority.to_account_info(),  
                    update_authority: ctx.accounts.authority.to_account_info(),  
                    system_program: ctx.accounts.system_program.to_account_info(),  
                    rent: ctx.accounts.rent.to_account_info(),  
                },  
                &[&seeds[..]],  
            ),  
            DataV2 {  
                name,  
                symbol,  
                uri,  
                seller_fee_basis_points: 0,  
                creators: None,  
                collection: None,  
                uses: None,  
            },  
            true,  
            true,  
            None,  
        )?;  
  
        msg!("Run create master edition v3");  
  
        create_master_edition_v3(  
            CpiContext::new_with_signer(  
                ctx.accounts.metadata_program.to_account_info(),  
                CreateMasterEditionV3 {  
                    edition: ctx.accounts.master_edition_account.to_account_info(),  
                    payer: ctx.accounts.payer.to_account_info(),  
                    mint: ctx.accounts.mint.to_account_info(),  
                    metadata: ctx.accounts.nft_metadata.to_account_info(),  
                    mint_authority: ctx.accounts.authority.to_account_info(),  
                    update_authority: ctx.accounts.authority.to_account_info(),  
                    system_program: ctx.accounts.system_program.to_account_info(),  
                    token_program: ctx.accounts.token_program.to_account_info(),  
                    rent: ctx.accounts.rent.to_account_info(),  
                },  
                &[&seeds[..]],  
            ),  
            Some(1),  
        )?;

        msg!("铸造NFT成功");  
  
        Ok(())  
    }  
  
    pub fn mint_to_collection(  
        ctx: Context<MintToCollection>,  
        id_collection: u64,  
        id_nft: u64,  
        name: String,  
        symbol: String,  
        uri: String,  
        price: f32,  
        cant: u64,  
    ) -> Result<()> {  
        msg!("创建种子");  
        let id_bytes = id_collection.to_le_bytes();  
        let id_nft_bytes = id_nft.to_le_bytes();  
        let seeds = &[  
            "mint".as_bytes(),  
            id_bytes.as_ref(),  
            id_nft_bytes.as_ref(),  
            &[ctx.bumps.mint],  
        ];  
  
        msg!("运行mint_to");  
  
        mint_to(  
            CpiContext::new_with_signer(  
                ctx.accounts.token_program.to_account_info(),  
                MintTo {  
                    authority: ctx.accounts.authority.to_account_info(),  
                    to: ctx.accounts.token_account.to_account_info(),  
                    mint: ctx.accounts.mint.to_account_info(),  
                },  
                &[&seeds[..]],  
            ),  
            1, // 1 代币  
        )?;  
  
        msg!("运行创建元数据账户v3");  
  
        create_metadata_accounts_v3(  
            CpiContext::new_with_signer(  
                ctx.accounts.metadata_program.to_account_info(),  
                CreateMetadataAccountsV3 {  
                    payer: ctx.accounts.payer.to_account_info(),  
                    mint: ctx.accounts.mint.to_account_info(),  
                    metadata: ctx.accounts.nft_metadata.to_account_info(),  
                    mint_authority: ctx.accounts.authority.to_account_info(),  
                    update_authority: ctx.accounts.authority.to_account_info(),  
                    system_program: ctx.accounts.system_program.to_account_info(),  
                    rent: ctx.accounts.rent.to_account_info(),  
                },  
                &[&seeds[..]],  
            ),  
            DataV2 {  
                name,  
                symbol,  
                uri,  
                seller_fee_basis_points: 0,  
                creators: Some(vec![Creator {  
                    address: ctx.accounts.payer.key(),  
                    verified: true,  
                    share: 100,  
                }]),  
                collection: Some(Collection {  
                    key: ctx.accounts.collection.key(),  
                    verified: false,  
                }),  
                uses: None,  
            },  
            true,  
            true,  
            None,  
        )?;  
  
        msg!("运行创建主版本v3");  
  
        create_master_edition_v3(  
            CpiContext::new_with_signer(  
                ctx.accounts.metadata_program.to_account_info(),  
                CreateMasterEditionV3 {  
                    edition: ctx.accounts.master_edition_account.to_account_info(),  
                    payer: ctx.accounts.payer.to_account_info(),  
                    mint: ctx.accounts.mint.to_account_info(),  
                    metadata: ctx.accounts.nft_metadata.to_account_info(),  
                    mint_authority: ctx.accounts.authority.to_account_info(),  
                    update_authority: ctx.accounts.authority.to_account_info(),  
                    system_program: ctx.accounts.system_program.to_account_info(),  
                    token_program: ctx.accounts.token_program.to_account_info(),  
                    rent: ctx.accounts.rent.to_account_info(),  
                },  
                &[&seeds[..]],  
            ),  
            Some(1),  
        )?;  
  
        msg!("铸造NFT成功");  
  
        Ok(())  
    }  
  
}  
  
#[derive(Accounts)]  
#[instruction(id: u64)]  
pub struct CreateNFT<'info> {  
    #[account(mut)]  
    pub authority: Signer<'info>,  
    #[account(mut)]  
    pub payer: Signer<'info>,  
    #[account(   
    init,  
    payer = payer,   
    mint::decimals = 0,  
    mint::authority = authority,  
    mint::freeze_authority = authority,  
    seeds = ["mint".as_bytes(), id.to_le_bytes().as_ref()],   
    bump,  
    )]  
    pub mint: Account<'info, Mint>,  
    #[account(  
        init_if_needed,  
        payer = payer,  
        associated_token::mint = mint,  
        associated_token::authority = payer,  
    )]  
    pub token_account: Account<'info, TokenAccount>,  
    pub associated_token_program: Program<'info, AssociatedToken>,  
    pub rent: Sysvar<'info, Rent>,  
    pub system_program: Program<'info, System>,  
    pub token_program: Program<'info, Token>,  
    pub metadata_program: Program<'info, Metadata>,  
    #[account(  
        mut,  
        seeds = [  
            b"metadata".as_ref(),  
            metadata_program.key().as_ref(),  
            mint.key().as_ref(),  
            b"edition".as_ref(),  
        ],  
        bump,  
        seeds::program = metadata_program.key()  
    )]  
    /// CHECK:  
    pub master_edition_account: UncheckedAccount<'info>,  
    #[account(  
        mut,  
        seeds = [  
            b"metadata".as_ref(),  
            metadata_program.key().as_ref(),  
            mint.key().as_ref(),  
        ],  
        bump,  
        seeds::program = metadata_program.key()  
    )]  
    /// CHECK:  
    pub nft_metadata: UncheckedAccount<'info>,  
}  
  
#[derive(Accounts)]  
#[instruction(id_collection: u64, id_nft: u64)]  
pub struct MintToCollection<'info> {  
    #[account(mut)]  
    pub authority: Signer<'info>,  
    #[account(mut)]  
    pub payer: Signer<'info>,  
    #[account(   
    init,  
    payer = payer,   
    mint::decimals = 0,  
    mint::authority = authority,  
    mint::freeze_authority = authority,  
    seeds = ["mint".as_bytes(),   
             id_collection.to_le_bytes().as_ref(),  
             id_nft.to_le_bytes().as_ref()],   
    bump,  
    )]  
    pub mint: Account<'info, Mint>,  
    #[account(  
        init_if_needed,  
        payer = payer,  
        associated_token::mint = mint,  
        associated_token::authority = payer,  
    )]  
    pub token_account: Account<'info, TokenAccount>,  
    pub associated_token_program: Program<'info, AssociatedToken>,  
    pub rent: Sysvar<'info, Rent>,  
    pub system_program: Program<'info, System>,  
    pub token_program: Program<'info, Token>,  
    pub metadata_program: Program<'info, Metadata>,  
    #[account(  
        mut,  
        seeds = [  
            b"metadata".as_ref(),  
            metadata_program.key().as_ref(),  
            mint.key().as_ref(),  
            b"edition".as_ref(),  
        ],  
        bump,  
        seeds::program = metadata_program.key()  
    )]  
    /// CHECK:  
    pub master_edition_account: UncheckedAccount<'info>,  
    #[account(  
        mut,  
        seeds = [  
            b"metadata".as_ref(),  
            metadata_program.key().as_ref(),  
            mint.key().as_ref(),  
        ],  
        bump,  
        seeds::program = metadata_program.key()  
    )]  
    /// CHECK:  
    pub nft_metadata: UncheckedAccount<'info>,  
    /// CHECK:  
    pub collection: UncheckedAccount<'info>,  
}

我们将在终端中执行Build并获得“Build Succesful”的结果。

现在我们使用Deploy部署我们的程序，并在完成此过程后。

我们现在准备测试我们的程序。

Solana大家也可以使用这个工具， https://www.ggg.dog
gtoken208
关注
Solana开发之Anchor框架
西京刀客
07-11 441
Anchor 是一个功能强大的框架，旨在快速构建安全的 Solana 程序。它通过减少诸如账户（反）序列化和指令数据等领域的样板文件、进行必要的安全检查、自动生成客户端库以及提供广泛的测试环境来简化开发流程。
下一代 Solana NFT 标准之Metaplex Core（“Core”）
西京刀客
07-14 464
Metaplex Core（“Core”）摆脱了以前标准的复杂性和技术债务，为数字资产提供了一个干净简单的核心规范。与替代方案相比，下一代 Solana NFT 标准使用单一账户设计，降低了铸币成本并提高了 Solana 网络负载。**它还具有灵活的插件系统，允许开发人员修改资产的行为和功能。**
如何使用 Rust 和 Metaplex 在 Solana 上铸造 NFT
chinadefi的博客
04-19 1126
如何使用 Rust 和 Metaplex 在 Solana 上铸造 NFT 在这一篇文章中，我们将学习如何编写一个自定义合约，并且只需要四个步骤就可以生成NFT。 关于Solana开发的一些提示 在Solana的开发过程中，我们会遇到很多奇怪的自定义错误和bug，因为Solana的开发生态系统不像以太坊的开发生态系统那么大，所以修复它们会非常困难和令人沮丧。但不用担心。当我们陷入困境时，我们只需要在正确的地方寻找解决方案。 项目概述 我们将使用的工具： Solana CLI工具——Solana 官方
SPL-404：如何彻底改变Solana上的NFT与DeFi
Lovely_xwys的博客
07-04 1473
要准确评估SPL-404在Solana上用于NFT的好处，必须查阅Solana的官方文档、开发者资源和社区讨论，以获取最新的信息和见解。要获取关于SPL-404最新的发展和路线图的最准确和最新的信息，建议查阅Solana的官方公告、开发者资源和社区论坛。然而，Solana确实有一些既定的Token标准，如SPL（Solana程序库），用于各种用途，包括NFT。本文将深入探讨NFT的机制，探索流行的平台和技术，剖析智能合约的功能，讨论推出NFT项目的关键考虑因素，并揭示塑造这一动态生态系统的未来趋势。
【在Solana中使用固定PDA账号实现管理员权限验证和全局状态变量保存】
天草降临的博客
01-23 5943
在Solana中使用固定PDA账号实现管理员权限验证和全局状态变量保存
Solana开发之Anchor框架-部署到 Devnet
西京刀客
07-19 631
Solana开发之Anchor框架-部署到 Devnet
145-Solana入门（九）- 合约部署和调用
Lich Howger
05-13 2077
人生还很长 路还很长 还有好多事情要做 还有好多人要保护 为什么人们总是不快乐 欲望太强 内心太弱 希望自己可以和这个世界更好地相处 不要反反复复地陷入漩涡 今天来看一下最简单的合约部署和调用 我们拿anchor的示例代码来举例 use anchor_lang::prelude::*; declare_id!("Fg6PaFpoGXkYsidMpWTK6W2BeZ7FEfcYkg476zPFsLnS"); #[program] mod basic_0 { ...
Solana中利用Anchor自动解析TokenAccount
天草降临的博客
11-20 6720
在Solana区块链中，绝大多数应用都会涉及到spl-token，因此获取用户账号(TokenAccount)中的信息是一个很常见的需求。而传统的方法直接读取底层数据相关位置的切片转换成所需要的数据，不仅繁琐还容易出错。Anchor 工具定义了几个特型协议，借助该协议可以自动实现数据结构的序列化与反序列化。本文介绍了使用Anchor来自动获取TokenAccount中所有数据的方法。
锚：:anchor:Solana海平面框架
02-10
锚 :anchor: Anchor是Solana 运行时的框架，提供了几个方便的开发人员工具。 Rust eDSL用于编写Solana程序 规格 用于从IDL生成客户端的TypeScript包 CLI和工作区管理，用于开发完整的应用程序 如果你熟悉复仇的...
用于 Solana 代币和 NFT 的 基于命令行的空投工具_JavaScript_代码_下载
07-02
用于 Solana 的基于 guerilla tactix 命令行的空投工具，没有抛光和最大功能。 快速启动设置 设置Solana 工具套件 设置spl-token 将您的配置设置为您将空投的网络，例如。测试网solana config set --url ...
TreatToolbox：糖果机Solana的生成NFT实用程序___下载.zip
04-19
TreatToolbox：糖果机Solana的生成NFT实用程序___下载.zip
Qt C++设计模式-＞享元模式
m0_46494667的博客
09-24 1129
享元模式（Flyweight Pattern）是一种结构型设计模式，旨在通过共享相同对象来减少内存使用，尤其适合在大量重复对象的情况下。它通过将对象的可共享部分抽取出来，并在多个上下文中共享，从而避免对象的多次创建。
QT-GUI(1)- QPushButton-QLabel-QTreeWidget-QTableWidget
aggie4628的专栏
09-27 248
QT 控件调参，供大家参考 QPushButton-QLabel-QTreeWidget-QTableWidget
Win10 QT 配置Android开发环境-jdk/sdk/gradle
最新发布
qq_58539881的博客
09-27 459
QT开发android是可行的,QT拥有非常强的跨平台能力,能使用C++开发几乎全平台的应用,但是环境配置坑挺多的.本次提供了QT6安装配置环境到完成app打包运行的整个过程,但是注意时效,因为qt的版本一直在变
再谈QT的界面开发 - QT的社区版本的获取 - 2024-09
山云的专栏
09-27 525
QT的跨平台特性，赋予了QT的生命。2024年，因为项目的原因，重新开启了一个基于QT的跨平台项目。QT有付费的版本和社区的版本。
Qt播放音效或音乐使用QSoundEffect类
qq_15181569的博客
09-24 278
首先，通过调用setSource()方法，你可以指定要播放的音效文件的路径。然后，通过调用play()方法，你可以开始播放音效。你还可以通过设置其他属性来控制音效的音量、循环播放、音效音调、音效速度等。总之，QSoundEffect是一个简单易用的Qt类，用于播放音效。它提供了一种方便的方式来加载和播放音效文件，并提供了一些属性和方法来控制音效的播放。QSoundEffect还提供了一些方法，如pause()、stop()、isPlaying()等，以便你可以进一步控制音效的播放。
qt中QTatlewidget类常用操作表格的函数有哪些？
学无止尽，谨言慎行！
09-23 469
在Qt中，类提供了丰富的函数来操作表格数据。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值