AI 驱动智能合约开发：从提示词工程到链上验证的工程化实践

qq_40635035

1053人浏览 · 2026-06-27 08:50:54

qq_40635035 · 2026-06-27 08:50:54 发布

AI 驱动智能合约开发：从提示词工程到链上验证的工程化实践

cover

一、手写万行 Solidity 的困局：AI 辅助开发的真实需求

智能合约开发面临一个独特矛盾：业务逻辑复杂度持续攀升，但调试成本极高——一次部署到主网的交易无法回滚。一个中等规模的 DeFi 协议，核心合约通常超过 3000 行 Solidity 代码，涉及代币经济学、治理投票、闪电贷清算等多模块交互。传统开发流程中，编写、测试、审计的周期长达数周。

大语言模型的出现为这一困局提供了新思路。LLM 在代码生成领域的能力已经得到广泛验证，但直接让 AI 生成完整合约并上线的做法极其危险——模型幻觉、上下文截断、安全漏洞遗漏等问题，在不可逆的链上环境中会被无限放大。真正可行的路径，是将 AI 定位为"辅助 Copilot"而非"替代开发者"，通过工程化的提示词设计与验证流程，让 AI 在受控范围内提升开发效率。

二、AI 辅助合约开发的架构：三层验证闭环

AI 生成合约代码的核心挑战不在于"能否生成"，而在于"如何验证"。一个工程化的 AI 辅助开发系统，必须构建从生成到验证的闭环架构。

flowchart TB
    A[需求描述<br/>自然语言规范] --> B[提示词工程层<br/>结构化 Prompt 模板]
    B --> C[LLM 生成层<br/>GPT-4 / Claude 代码输出]
    C --> D[静态分析层<br/>Slither + Solhint]
    D -->|通过| E[符号执行层<br/>Mythril 深度检测]
    D -->|失败| F[反馈修复层<br/>错误信息回注 Prompt]
    F --> B
    E -->|通过| G[测试生成层<br/>AI 生成 Foundry 测试用例]
    E -->|失败| F
    G -->|覆盖率 ≥ 95%| H[人工审计<br/>最终确认]
    G -->|覆盖率不足| F
    H --> I[部署上链<br/>多签 + 时间锁]

    style F fill:#ff6b6b,color:#fff
    style H fill:#4ecdc4,color:#fff
    style I fill:#45b7d1,color:#fff

上图展示了三层验证闭环的核心流程。关键设计原则：AI 生成的代码必须经过自动化工具验证，验证失败的信息必须回注到提示词中形成修复循环，而非人工逐行排查。这种"生成-验证-修复"的迭代模式，将 AI 的代码生成能力约束在安全边界内。

三、生产级提示词模板与代码验证流水线

3.1 结构化提示词模板

import json
from typing import Optional

PROMPT_TEMPLATE = """
你是一名 Solidity 安全审计专家与合约开发者。请根据以下规范生成合约代码。

## 项目规范
- Solidity 版本: {sol_version}
- 合约类型: {contract_type}
- 核心功能: {core_features}

## 安全约束（必须严格遵守）
1. 所有外部调用必须遵循 Checks-Effects-Interactions 模式
2. 关键函数必须使用 nonReentrant 修饰符
3. 权限控制必须使用 OpenZeppelin 的 AccessControl
4. 禁止使用 tx.origin 进行身份验证
5. 禁止使用 block.timestamp 作为唯一随机源
6. 所有算术运算使用 Solidity 0.8+ 内置溢出检查

## 输出格式
1. 完整合约代码（含 NatSpec 注释）
2. 每个外部函数的安全分析说明
3. 潜在风险点列表
"""

def build_prompt(
    sol_version: str = "^0.8.20",
    contract_type: str = "DeFi Vault",
    core_features: str = "存款、提取、收益分配",
    security_incidents: Optional[str] = None,
) -> str:
    """
    构建结构化提示词，注入安全约束与历史漏洞上下文。
    security_incidents 参数用于回注验证失败信息，形成修复闭环。
    """
    prompt = PROMPT_TEMPLATE.format(
        sol_version=sol_version,
        contract_type=contract_type,
        core_features=core_features,
    )

    # 如果存在验证失败的历史信息，追加到提示词末尾
    if security_incidents:
        prompt += f"""
## 上次生成的代码存在以下问题（必须修复）
{security_incidents}

请针对以上问题逐一修复，并在安全分析说明中解释修复方案。
"""
    return prompt


def parse_llm_output(raw_output: str) -> dict:
    """
    解析 LLM 输出，提取合约代码、安全分析与风险点。
    返回结构化字典，供后续验证流水线使用。
    """
    result = {
        "contract_code": "",
        "security_analysis": "",
        "risk_points": [],
    }

    # 提取代码块
    if "```solidity" in raw_output:
        code_block = raw_output.split("```solidity")[1].split("```")[0]
        result["contract_code"] = code_block.strip()

    # 提取风险点列表
    lines = raw_output.split("\n")
    for line in lines:
        stripped = line.strip()
        if stripped.startswith("- ") and "风险" in raw_output.split(stripped)[0][-50:]:
            result["risk_points"].append(stripped[2:])

    return result

3.2 自动化验证流水线

import subprocess
import logging
from pathlib import Path

logger = logging.getLogger("ai-contract-pipeline")

class ContractValidator:
    """合约验证流水线——将 AI 生成代码送入静态分析与符号执行工具"""

    def __init__(self, contract_path: str, solc_version: str = "0.8.20"):
        self.contract_path = Path(contract_path)
        self.solc_version = solc_version
        self.issues: list[str] = []

    def run_slither(self) -> bool:
        """执行 Slither 静态分析，返回是否通过"""
        try:
            result = subprocess.run(
                ["slither", str(self.contract_path),
                 "--solc-disable-warnings",
                 "--exclude-dependencies",
                 "--json", "-"],
                capture_output=True, text=True, timeout=120,
            )
            if result.returncode != 0:
                # 解析 JSON 输出，提取高/中风险问题
                detectors = json.loads(result.stdout).get("results", {}).get("detectors", [])
                for d in detectors:
                    if d.get("impact") in ("High", "Medium"):
                        self.issues.append(
                            f"[{d['impact']}] {d['check']}: {d['description']}"
                        )
                return len(self.issues) == 0
            return True
        except subprocess.TimeoutExpired:
            logger.error("Slither 分析超时，合约可能过于复杂")
            self.issues.append("Slither timeout - contract too complex")
            return False
        except Exception as e:
            logger.error(f"Slither 执行异常: {e}")
            self.issues.append(f"Slither error: {str(e)}")
            return False

    def run_solhint(self) -> bool:
        """执行 Solhint 代码规范检查"""
        try:
            result = subprocess.run(
                ["solhint", str(self.contract_path), "-f", "json"],
                capture_output=True, text=True, timeout=60,
            )
            # Solhint 退出码非 0 表示存在违规
            if result.returncode != 0:
                errors = json.loads(result.stdout)
                for err in errors:
                    if err.get("severity") == "error":
                        self.issues.append(f"[Solhint] {err['message']}")
                return not any("error" in i for i in self.issues)
            return True
        except Exception as e:
            logger.warning(f"Solhint 执行异常（非致命）: {e}")
            return True  # 规范检查失败不阻断流程

    def validate(self) -> tuple[bool, str]:
        """
        执行完整验证流水线。
        返回 (是否通过, 问题汇总字符串)。
        问题汇总字符串可直接回注到提示词中。
        """
        slither_ok = self.run_slither()
        solhint_ok = self.run_solhint()

        passed = slither_ok and solhint_ok
        issues_text = "\n".join(self.issues) if self.issues else "无问题"
        return passed, issues_text

上述流水线的核心设计：validate() 方法返回的问题汇总字符串，可以直接作为 build_prompt() 的 security_incidents 参数，实现"验证失败 → 回注提示词 → 重新生成"的自动修复循环。