如何使用 AI 构建 Solana 应用

Solana AI 开发挑战

Solana 独特的架构和要求可能给 AI 带来困难。如果 AI 未能考虑这些因素，你就会浪费时间调试代码或重写程序，这与使用 AI 简化开发的初衷背道而驰。

Solana 的独特架构

Solana 主要在三个方面与众不同：

1. 基于账户的模型

Ethereum 等许多区块链将数据直接绑定到智能合约的内部存储。相比之下，Solana 的编程模型以“账户”为核心组织一切。数据保存在这些账户中，而“程序”（Solana 中与智能合约对应的概念）则修改这些数据并与之交互。 

一个关键区别是，在 Solana 上，一切都是账户，程序本身也不例外。程序只是存储可执行数据的账户，因此能够处理指令。相比之下，Ethereum 区分由私钥控制的外部拥有账户（EOA）与拥有代码和内部存储的智能合约。 

这种根本差异可能导致误解，尤其是在编写 Solana 代码时。与 Ethereum 智能合约类似，不熟悉账户模型的开发者可能会错误地认为程序可以拥有自己的数据。在部署到 Solana 时，这类假设可能引发运行时错误或安全漏洞。

2. 程序派生地址（PDA）

程序派生地址（PDA）由程序 ID 和种子生成。PDA 让程序无需私钥即可组织账户。不过，AI 模型可能无法识别标准地址和 PDA 之间的区别。如果它忘记处理种子或检查所有权，生成的代码在 Rust 层面可能正确，但并不符合 Solana 的要求。

3. 并行执行

Solana 的运行时 Sealevel 能够并行处理交易，不同于每次只处理一笔交易的传统区块链。这是因为交易会明确指定要读取和写入哪些账户。借助这些信息，Solana 可以确定哪些账户需要加锁，并安全地同时执行多笔交易。 

AI 经常误解这种模型。它可能假定交易会像在 Ethereum Virtual Machine（EVM）中一样按顺序运行，进而生成未针对并行性优化的代码。由于 Solana 基于账户的锁定系统与 EVM 的方式不同，AI 编写的代码可能性能不佳或难以扩展。

常见痛点

开发者使用 AI 构建 Solana 应用时，通常会反复遇到以下问题：

1. 错误的代码

AI 可能给出能通过 Rust 编译、但部署到 Solana 后无法运行的函数。例如，AI 结对编程工具可能遗漏签名者或错误理解账户引用。结果呢？你只有在运行测试、执行真实交易或完成安全审计后，才能发现 bug 或安全漏洞。

2. 未充分优化的代码

即使 AI 生成的代码可以运行，也可能没有针对计算单元进行优化，导致交易处理缓慢，或引入难以察觉的隐藏瓶颈。比如，AI 可能编写一个逐个更新账户的函数，却没有意识到，只要实现方式正确，Solana 就能并发处理这些账户。

3. 调试困难

除非你主动告知，否则 AI 模型并不知道你的文件夹结构，也不了解你如何定义自定义数据类型。这意味着它可能提出与你现有设置冲突的解决方案，而将这些方案重新合并到项目中可能会非常麻烦。

使用 Helius AI 工具更快发布 Solana 应用

如上所述，使用 AI 在 Solana 上正确构建应用并不容易。 

为改变这一现状，我们构建了一套 Solana AI 开发者工具，替你处理棘手环节：路由到正确的工具、应用最佳实践，并为 AI 智能体提供从一条提示词走向生产级应用所需的基础。

Helius MCP Server

Helius MCP Server 基于 Anthropic 的开放 Model Context Protocol（MCP）标准构建，可向任何兼容 MCP 的客户端（Claude Desktop、Cursor、VS Code、Windsurf 等）提供 60 多种结构化工具，包括 getBalance、parseTransaction、getAssetsByOwner 和 createWebhook。

智能体无需构造原始 curl 命令并解析 JSON 输出，而是可以发起带类型的工具调用，直接接收结构化响应。这让每次 API 交互都更快、更可靠，也更不容易出错。

只需一条命令即可将它添加到 Claude Code：

claude mcp add helius npx helius-mcp@latest

Helius Skills

如果智能体不知道如何使用工具，那么即使能访问 60 多种工具也没有意义。https://www.helius.dev/blog/helius-for-agents#helius-skills-the-brain

Skills 是专家级指令集，由包含路由逻辑和参考文件的精心设计提示词组成，教会智能体如何成为 Solana 开发专家。

加载 skill 后，智能体会知道查询 NFT 时应使用 searchAssets 而不是 getProgramAccounts，动态获取优先费，并通过 Sender 路由交易以实现最高上链成功率。 

我们推出了四种 skill：

• 构建 – 涵盖所有 Helius API 的核心 Solana 开发
• DFlow – 使用 DFlow API 的交易应用
• Phantom – 使用 Phantom Connect SDK 为 dApp 构建前端
• SVM – 深入了解 Solana 协议内部机制

Skills 与模型无关，可配合 OpenAI API、Claude API、Cursor Rules 和 ChatGPT 自定义指令使用。

如需贡献 skill，请填写此表单。

Helius CLI

Helius CLI 是功能齐全的命令行界面，提供 95 多条命令，涵盖账户管理、交易发送、webhook 管理、实时流式传输、质押、ZK Compression 等功能。 

你可以直接使用它，也可以让智能体操作它——每条命令都支持 --json 输出和结构化退出代码，便于智能体解析响应并以编程方式处理错误。

按以下方式安装 Helius CLI：

npm install -g helius-cli

Helius Claude Code Plugin

Claude Code Plugin 将 Helius MCP、DFlow MCP、全部四种 skill，以及每款 Helius 产品的深度参考文件打包为一次安装——无需手动配置 MCP，也无需单独设置 skill。

安装方式如下：

/plugin marketplace add helius-labs/core-ai
/plugin install helius@helius-labs

安装后，只需输入一条类似 “为这个钱包构建一个税务报告 CLI” 的提示词，就能生成一个功能完整、支持分页的 CLI 应用——无需中间提示。

这些工具共同为 AI 智能体提供所需的工具和领域知识，使其跳过反复试错阶段，从第一条提示词开始就能生成正确且经过优化的 Solana 代码。

Solana AI 开发技巧

使用 AI 构建 Solana 应用时，请遵循以下建议：

1. 从高质量提示词开始

系统提示词就像 AI 的职位说明。它会告诉 AI 自己扮演的角色（例如“你是一名使用 Anchor 进行 Solana 编程的专家……”），并列出你希望它遵循的规则。

下面是一个稍作扩展的典型示例：

# You are an expert in Solana program development.
Specializing in building and deploying smart contracts using Rust and Anchor,
and integrating on-chain data with @solana/web3.js.

---

## General Guidelines
- Write secure, efficient, and maintainable code for Solana programs.
- Thoroughly test and audit all programs before deployment.

## Solana Program Development with Rust and Anchor
- Prioritize Rust's safety and performance.
- Use Anchor macros to simplify account management, error handling, and
  data serialization.
- Keep code modular and maintain a clear separation between logic and data.

## Security and Best Practices
- Enforce strict access controls--ensure only permitted signers can modify data.
- Use PDAs responsibly: validate seeds and ownership checks to prevent conflicts.

## Performance and Optimization
- Minimize transaction costs by bundling operations efficiently.
- Exploit parallelism--don't serialize steps unnecessarily.
- Regularly benchmark your code to spot and remove performance

为什么有效

编写良好的系统提示词就像一份蓝图，能让 AI 与 Solana 的架构保持一致，从而确保每个响应都准确、安全，并贴合你的需求。

1. 设置正确的上下文：将 AI 定义为“Solana 专家”，可确保它专注于 PDA、并行性和 Anchor 等 Solana 特有功能，而不是套用通用的区块链假设。
2. 生成一致的代码：加入严格访问控制和并行执行等最佳实践，可以引导 AI 生成安全、可靠且可预测的结果。
3. 避免常见错误：强调 Rust 安全性、Anchor 宏和序列化可以减少错误，节省调试和重写代码的时间。
4. 发挥 Solana 的优势： AI 必须提高带宽并降低延迟，从而针对 Solana 的高吞吐量和效率优化代码。

2. 编写清晰的提示词

要求 AI 生成代码时，精确至关重要。描述越精确，结果就越好。请比较以下示例：

糟糕的提示词：

“编写一个初始化账户的函数。”

这个提示词过于模糊。AI 不知道要使用哪种编程语言或框架，也不知道这是针对 Solana 代码的要求。它可能会给出通用或毫无用处的代码。

优秀的提示词：

“使用 Rust 和 Anchor 编写一个函数，用于初始化 Solana 代币账户。使用由种子派生的 PDA。验证账户状态，如果账户已经初始化，则进行错误处理。”

优秀提示词为何有效：

清晰的提示词有助于节省时间和精力。明确 AI 的目标，可以避免它生成草率、含糊或偏离目标的代码，导致后续不得不修正。这样也能最大限度减少误解，让 AI 协作更高效。 

1. 清晰直接：直接指定 Rust、Anchor 和 PDA 后，AI 就能确切知道要使用哪些工具和功能，无需猜测，也不会加入无关细节。
2. 聚焦 Solana 的要求：提到 PDA 会让 AI 加入 Solana 特有的逻辑。否则，代码可能遗漏安全派生地址等重要步骤。
3. 在必要处增加深度：验证和错误处理指令要求 AI 不止完成基础功能，有助于确保代码能在真实场景中运行。

优秀的提示词就像地图，可以引导 AI、帮助它避开陷阱并实现目标。

3. 提供适当的上下文

为 AI 提供适当的上下文，可以让它表现得更好。许多工具允许你上传代码或链接文件。这有助于 AI 理解你的项目，并生成适合你代码库的解决方案。 

但不要提供过多信息。向 AI 输入整个大型代码库等海量信息，可能导致它产生幻觉或给出无关响应。 

你应该只提供代码中的相关部分。这样能让 AI 保持专注，并提高建议质量。

例如，假设你的应用已有一个定义自定义数据结构的文件：

#[account]
pub struct TokenAccount {
    pub balance: u64,
    pub is_initialized: bool,
    // ... more fields
}

如果上传此文件或将其作为输入的一部分，AI 就能在生成的代码中使用你准确的字段名（balance、is_initialized）。

它还可以让建议与你的项目结构和约定保持一致。

为什么提供上下文有效

1. 提高准确性：如果没有上下文，AI 可能会猜测字段名、引入不必要的更改，或假设错误的数据类型。例如，它可能将你的余额字段命名为 amount，或使用 f64 而不是 u64。提供实际的 struct 可以消除这些猜测。
2. 保持代码一致：AI 理解你的命名约定后，会生成能自然融入项目的代码。你无需再重命名变量，也不必返工以匹配现有模式。
3. 减少集成工作：如果 AI 能看到你的账户结构，就可以调整输出以直接与其集成，从而避免大幅重写 AI 生成的代码来适配现有逻辑。

示例：如何添加上下文以改进 AI 输出

如果没有适当的上下文，像 “编写一个更新代币账户余额的函数” 这样的提示词可能会让 AI 生成以下代码：

pub fn update_balance(ctx: Context<UpdateAccount>, amount: f64) -> Result<()> {
    let account = &mut ctx.accounts.token_account;
    account.amount += amount;
    Ok(())
}

这段代码有两个问题：

首先，它为 amount 使用了 f64，而不是 u64。 

Solana 对原生浮点运算的支持非常有限。更推荐使用定点运算，并根据所用小数位数缩放数值，从而避免性能和兼容性问题。

其次，它将余额字段称为 amount，与 struct 不匹配。这可能在将来造成困惑和 bug。

现在，如果你将 TokenAccount struct 作为上下文提供给 AI，它可能会改为生成：

pub fn update_balance(ctx: Context<UpdateAccount>, amount: u64) -> Result<()> {
    let token_account = &mut ctx.accounts.token_account;
    token_account.balance += amount;
    Ok(())
}

这个输出与你的项目更加匹配。 

不过，即使有了这一改进，也值得为 token_account.balance += amount 操作添加溢出检查，确保代码稳健且安全。

如何提供上下文

请记住以下步骤，为 AI 工具提供适当的上下文：

1. 上传文件：如果 AI 工具支持，请上传 struct 定义、账户 schema 和其他项目文件。
2. 在提示词中引用代码：将相关代码片段复制并粘贴到提示词中，供 AI 参考。
3. 描述结构：如果无法上传，请在提示词中清楚描述数据。例如，“我有一个名为 TokenAccount 的 struct，其中包含 balance（u64）和 is_initialized（bool）字段。”

4. 基于现有代码构建

你不必每次都从头开始。通常，你已经有一段可以正常运行、但仍可改进的代码。AI 可以帮助你优化它。下面是一个示例：

以下是原始代码：

pub fn create_token_account(ctx: Context<CreateAccount>) -> Result<()> {
    let token_account = &mut ctx.accounts.token_account;
    token_account.balance = 0;
    Ok(())
}

这段代码会初始化一个代币账户，并将余额设为零。它很简单，但没有处理更新现有账户或检查所有权等场景。

你的提示词：

“让这个函数更加稳健。如果代币账户已存在，则将指定金额加到余额中；否则，使用指定金额进行初始化。同时，确保该账户归当前程序所有。”

输入提示词后，AI 生成的代码如下：

pub fn create_or_update_token_account(
    ctx: Context<CreateAccount>,
    amount: u64
) -> Result<()> {
    let token_account = &mut ctx.accounts.token_account;

    // Check ownership
    if token_account.owner != ctx.program_id {
        return err!(ProgramError::IncorrectProgramId);
    }

    // Update or initialize
    if token_account.is_initialized {
        token_account.balance += amount;
    } else {
        token_account.balance = amount;
        token_account.is_initialized = true;
    }

    Ok(())
}

为什么有效

1. 处理常见场景： 新代码可以处理已初始化和未初始化的账户，因此更适合真实应用。
2. 增加所有权验证： 程序会检查自己是否拥有该账户，从而防止未经授权的更改。
3. 让函数更智能： 函数现在可以更新余额，而不是每次都将其重置为零。这减少了冗余，也更符合实际用例。
4. 节省时间： 你无需重写整个函数。AI 在现有代码的基础上进行了扩展，让你更快地将基础函数升级为稳健的函数。

如何使用这种方法

以后采用这种方法时，请记住以下步骤：

1. 从可运行的基础开始：找出能够运行但仍可改进的函数或代码片段。
2. 在提示词中具体说明：解释你想改进什么，例如增加错误检查、处理边界情况或优化逻辑。
3. 审查 AI 建议：检查 AI 生成的输出，确保它适合你的项目，并遵循 Solana 的最佳实践。
4. 按需迭代：如果第一次输出不够完美，请调整提示词或编辑代码，使其更接近你的目标。

5. 每次迭代一个步骤

分步构建代码有助于避免错误，并在过程中不断完善成果。不要试图一次创建复杂函数，而应将其拆分为更小的任务。这样可以在继续下一步之前，更轻松地测试和改进每个部分。

工作流示例

先从小任务开始。让 AI 编写一个使用种子计算程序派生地址（PDA）的简单函数。

下面是一个提示词示例：

“编写一个 Rust 函数，使用 Anchor 根据种子和程序 ID 计算 PDA。”

AI 的输出：

 pub fn find_pda(seed: &[u8], program_id: &Pubkey) -> Pubkey {
    Pubkey::create_program_address(&[seed], program_id).unwrap()
}

这是一个不错的起点，但还不完整。接下来添加错误处理。

检查代码并找出问题。例如，当种子无效时，使用 unwrap() 可能导致程序崩溃。

让 AI 修复这个问题：

“更新这个函数，为无效种子添加错误处理。返回 Result，而不是执行 unwrap。”

更新后的代码：

 pub fn find_pda(seed: &[u8], program_id: &Pubkey) -> Result<Pubkey, ProgramError> {
    Pubkey::create_program_address(&[seed], program_id)
        .map_err(|_| ProgramError::InvalidSeeds)
}

现在，函数会返回错误而不是发生 panic，从而妥善处理无效种子。

接下来，集成这个函数。 

让 AI 在更大的例程中使用该 PDA 函数。例如：

“编写一个使用此 PDA 创建新代币账户的函数。验证该 PDA 尚未被使用。”

以下是 AI 的输出：

pub fn create_token_account(ctx: Context<CreateAccount>, seed: &[u8], amount: u64) -> Result<()> {
    let program_id = ctx.program_id;
    let pda = find_pda(seed, &program_id)?;

    if ctx.accounts.token_account.key != pda {
        return Err(ProgramError::InvalidSeeds);
    }

    if !ctx.accounts.token_account.is_initialized {
        let token_account = &mut ctx.accounts.token_account;
        token_account.balance = amount;
        token_account.is_initialized = true;
    }

    Ok(())
}

此步骤将 PDA 逻辑集成到账户创建中，同时确保 PDA 不会被错误地重复使用。

现在，优化并完成代码。使用类似以下的提示词，让 AI 进一步完善该函数：

“优化此函数以尽量降低交易成本，并加入所有权验证。”

以下是 AI 的输出：

pub fn create_token_account(ctx: Context<CreateAccount>, seed: &[u8], amount: u64) -> Result<()> {
    let program_id = ctx.program_id;
    let pda = find_pda(seed, &program_id)?;

    if ctx.accounts.token_account.key != pda || ctx.accounts.token_account.owner != program_id {
        return Err(ProgramError::IncorrectProgramId);
    }

    if !ctx.accounts.token_account.is_initialized {
        let token_account = &mut ctx.accounts.token_account;
        token_account.balance = amount;
        token_account.is_initialized = true;
    }

    Ok(())
}

最终函数现在高效、安全，并符合 Solana 的最佳实践。

这种方法为何有效

1. 让任务易于管理：每次专注于一个小任务，可以避免 AI 不堪重负。每一步都建立在上一步的基础上，更容易测试和完善。
2. 尽早发现错误：步骤越小，就越容易在问题影响其余代码之前发现它。例如，尽早添加错误处理可以防止以后发生崩溃。
3. 促进迭代：如果某个部分效果不理想，你可以调整该函数，而无需返工整个代码库。
4. 生成更好的代码：每次完善都会让代码更加稳健，最终得到更可靠、更易维护的解决方案。

如何使用这种方法

下次与 AI 结对编程时，请记住以下技巧：

1. 将任务拆分为更小的步骤：不要一次要求生成复杂函数，而应将其拆分为更简单、更易管理的任务，然后逐一执行。
2. 每一步后都测试结果：每次更改后都运行代码，确认其是否正常工作。如果不能，请修复问题或调整提示词，再继续下一步。
3. 在过程中不断完善：不要满足于单一结果。要求 AI 进行优化，或添加验证、性能改进和更完善的错误处理等功能。

总结

只要采用谨慎、周全的方法，使用 AI 在 Solana 上进行构建就能发挥强大作用。Solana 的架构不同于其他区块链，它使用 PDA、并行交易处理和基于账户的设计。这意味着你需要正确引导 AI。

首先使用清晰的提示词。准确告诉 AI 你想要什么，并明确指定 Rust、Anchor 和 PDA 等工具。优秀的提示词可以这样写：

“编写一个 Rust 函数，使用 PDA 初始化 Solana 代币账户，验证账户状态并处理错误。”

这种清晰度能提高 AI 生成适用于 Solana 的可运行代码的概率。

始终提供上下文。分享项目代码，或说明你使用的结构，例如账户 schema 或数据类型。比如，如果你有一个 TokenAccount struct，请提供其详细信息，以便 AI 调整输出。但不要提供过多信息。只关注相关部分，确保建议准确且有价值。

将任务拆分为更小的步骤。使用迭代流程逐步完善代码。从计算 PDA 等简单任务开始，再添加错误处理或账户验证。每一步之后都要测试。这样可以尽早发现问题，并稳步推进。

最后，仔细检查 AI 的工作。大多数情况下，AI 生成的代码也会存在一些小问题，例如缺少溢出检查或跳过验证。确保输出遵循 Solana 的规则、没有 bug，并充分利用并行执行能力。

AI 只是起点，最终仍需要你完成工作。通过清晰的指令、充分的上下文、分步开发和仔细审查，你可以使用 AI 创建安全且经过优化的 Solana 程序。持续参与整个过程，AI 就会成为帮助你节省时间、编写更好代码的宝贵工具。

延伸阅读

要进一步了解如何使用 AI 在 Solana 上构建应用，请查看以下资源：

1. Anthropic：提示词工程概述
2. AWS：提示词工程技巧
3. 优化 Solana 程序
4. 如何优化 Solana 上的计算资源使用
5. Anchor 文档