企业合同 AIGC 生成 + 区块链存证：智能合约化的工作流
一、"合同模板 + 填空"式生成，法务审到怀疑人生
企业合同的生成和管理是一个极度依赖模板和人工审核的流程。一个典型的合同签署流程：销售填模板 → 法务审核 → 修改 → 再审核 → 双方签字 → 扫描归档。这个过程平均耗时 3-5 个工作日。而且因为合同以 PDF 形式存储在共享文件夹中，事后查找某个条款的历史版本几乎不可能。
AIGC + 区块链的组合可以解决两个问题：AIGC 负责智能生成（根据交易背景自动起草条款，减少人工填充），区块链负责存证（合同哈希上链，防止事后篡改）。但这套方案的关键不是技术本身，而是如何将"人审核"的环节嵌入自动化的流程中。
二、智能合约化的工作流架构
核心设计是"生成-审核-签署-存证"的闭环：
每一个状态变更都在链上留下记录：合同生成的时间、法务审核的结果、签署的时间点——这些构成了完整的合规证据链。
三、Python 实现：合同 AIGC 生成 + 上链存证
import hashlib
import json
import time
from enum import Enum
from dataclasses import dataclass, asdict, field
from typing import List, Dict, Optional, Any
from datetime import datetime
class ContractStatus(Enum):
"""合同状态"""
DRAFT = "draft" # 草稿
LEGAL_REVIEW = "legal_review" # 法务审核中
PENDING_SIGN = "pending_sign"# 待签署
SIGNED = "signed" # 已签署
ARCHIVED = "archived" # 已归档
@dataclass
class ContractElement:
"""合同要素"""
party_a: str # 甲方
party_b: str # 乙方
amount: float # 合同金额
currency: str = "CNY"
service_scope: str = "" # 服务内容
start_date: str = "" # 合同开始日期 YYYY-MM-DD
end_date: str = "" # 合同结束日期
payment_terms: str = "" # 付款条件
special_clauses: List[str] = field(default_factory=list)
@dataclass
class ContractRecord:
"""合同链上记录"""
contract_id: str
status: ContractStatus
content_hash: str # 合同内容哈希
created_at: int # Unix 时间戳
legal_reviewed_at: Optional[int] = None
legal_reviewer: Optional[str] = None
legal_approved: bool = False
signed_at: Optional[int] = None
signer_a_hash: Optional[str] = None # 甲方签名哈希
signer_b_hash: Optional[str] = None # 乙方签名哈希
class ContractChain:
"""简化版区块链（实际项目对接联盟链）"""
def __init__(self):
self._records: Dict[str, List[ContractRecord]] = {}
def store(self, contract_id: str, record: ContractRecord) -> bool:
"""存证一条合同状态变更"""
if contract_id not in self._records:
self._records[contract_id] = []
self._records[contract_id].append(record)
return True
def query(self, contract_id: str) -> List[ContractRecord]:
"""查询合同全生命周期记录"""
return self._records.get(contract_id, [])
def verify(self, contract_id: str, content_hash: str) -> bool:
"""验证合同哈希是否与链上一致"""
records = self.query(contract_id)
if not records:
return False
# 检查最新的 SIGNED 状态记录的哈希
for record in reversed(records):
if record.status == ContractStatus.SIGNED:
return record.content_hash == content_hash
return False
class ContractGenerator:
"""AIGC 合同生成器"""
TEMPLATES = {
"service": """
# 服务合同
甲方：{party_a}
乙方：{party_b}
## 一、服务内容与范围
{service_scope}
## 二、合同期限
自 {start_date} 至 {end_date}
## 三、合同金额与支付方式
合同总金额：{amount:,.2f} {currency}
支付方式：{payment_terms}
## 四、双方权利与义务
1. 甲方应按约定时间支付合同款项
2. 乙方应按约定的服务质量标准完成服务
3. 任何一方变更合同内容需提前 15 个工作日书面通知对方
## 五、违约责任
1. 甲方逾期付款，每逾期一日按未付款项的 0.05% 支付违约金
2. 乙方未按约定完成服务，应承担相应的赔偿责任
## 六、争议解决
双方协商不成的，提交合同签订地人民法院裁决
## 七、其他
{special_clauses_text}
""".strip()
}
def __init__(self):
self.chain = ContractChain()
def generate_contract(
self, elements: ContractElement, contract_type: str = "service"
) -> Dict[str, Any]:
"""生成合同 + 存证"""
if elements.amount <= 0:
raise ValueError("合同金额必须大于 0")
if not elements.party_a or not elements.party_b:
raise ValueError("甲乙双方名称不能为空")
template = self.TEMPLATES.get(contract_type)
if template is None:
raise ValueError(f"不支持的合同类型: {contract_type}")
# 组装特殊条款
special_text = "\\n".join(
f" {i+1}. {clause}"
for i, clause in enumerate(elements.special_clauses)
) if elements.special_clauses else " 无"
# 填充模板
contract_text = template.format(
party_a=elements.party_a,
party_b=elements.party_b,
amount=elements.amount,
currency=elements.currency,
service_scope=elements.service_scope or "详见附件",
start_date=elements.start_date or "合同签订之日",
end_date=elements.end_date or "服务完成之日",
payment_terms=elements.payment_terms or "按约定支付",
special_clauses_text=special_text,
)
# 生成合同 ID
contract_id = self._generate_id(elements)
# 计算哈希
content_hash = self._compute_hash(contract_text)
# AIGC 合规检查
warnings = self._compliance_check(elements, contract_text)
# 上链存证（DRAFT 状态）
record = ContractRecord(
contract_id=contract_id,
status=ContractStatus.DRAFT,
content_hash=content_hash,
created_at=int(time.time()),
)
self.chain.store(contract_id, record)
return {
'contract_id': contract_id,
'contract_text': contract_text,
'content_hash': content_hash,
'compliance_warnings': warnings,
'status': ContractStatus.DRAFT.value,
'tx_id': f"tx_{int(time.time()):08d}",
}
def legal_review(
self, contract_id: str, reviewer: str, approved: bool
) -> bool:
"""法务审核存证"""
record = ContractRecord(
contract_id=contract_id,
status=ContractStatus.LEGAL_REVIEW,
content_hash="", # 审核不改变内容，沿用之前哈希
created_at=int(time.time()),
legal_reviewed_at=int(time.time()),
legal_reviewer=reviewer,
legal_approved=approved,
)
self.chain.store(contract_id, record)
return True
def record_signature(
self, contract_id: str, signer: str,
contract_text: str,
) -> Dict[str, Any]:
"""签署存证"""
# 模拟数字签名
signer_hash = self._compute_hash(
f"{signer}_{contract_text}_{time.time()}"
)
content_hash = self._compute_hash(contract_text)
record = ContractRecord(
contract_id=contract_id,
status=ContractStatus.SIGNED,
content_hash=content_hash,
created_at=int(time.time()),
signed_at=int(time.time()),
signer_a_hash=signer_hash if "甲" in signer else None,
signer_b_hash=signer_hash if "乙" in signer else None,
)
self.chain.store(contract_id, record)
return {
'contract_id': contract_id,
'signed_at': datetime.now().isoformat(),
'signer': signer,
'content_hash': content_hash,
'verified': self.chain.verify(
contract_id, content_hash
),
}
def verify_contract(
self, contract_id: str, contract_text: str
) -> Dict[str, Any]:
"""验证合同完整性"""
current_hash = self._compute_hash(contract_text)
chain_records = self.chain.query(contract_id)
if not chain_records:
return {
'verified': False,
'reason': '链上未找到该合同记录',
}
# 获取最近的签署记录
signed_record = None
for record in reversed(chain_records):
if record.status == ContractStatus.SIGNED:
signed_record = record
break
if signed_record is None:
return {
'verified': False,
'reason': '合同尚未签署',
'lifecycle': [
{'status': r.status.value, 'time': r.created_at}
for r in chain_records
],
}
verified = signed_record.content_hash == current_hash
return {
'verified': verified,
'current_hash': current_hash,
'chain_hash': signed_record.content_hash,
'lifecycle': [
{
'status': r.status.value,
'time': datetime.fromtimestamp(
r.created_at
).isoformat(),
'reviewer': r.legal_reviewer,
}
for r in chain_records
] if verified else [],
}
def _compliance_check(
self, elements: ContractElement, text: str
) -> List[str]:
"""合规性检查"""
warnings = []
# 金额异常检查
if elements.amount < 1000:
warnings.append("合同金额较低，建议确认是否为测试合同")
if elements.amount > 10000000:
warnings.append("合同金额超过 1000 万，建议高级法务审核")
# 关键条款缺失检查
if not elements.payment_terms:
warnings.append("未填写付款条件，建议补充")
if not elements.start_date:
warnings.append("未指定合同开始日期，将使用默认值")
return warnings
@staticmethod
def _compute_hash(content: str) -> str:
return hashlib.sha256(content.encode('utf-8')).hexdigest()
@staticmethod
def _generate_id(elements: ContractElement) -> str:
raw = f"{elements.party_a}{elements.party_b}{time.time()}"
return f"CONTRACT-{hashlib.md5(raw.encode()).hexdigest()[:12].upper()}"
四、边界分析与 Trade-offs
AIGC 生成 vs 人工审核的边界：AI 可以生成合同的 80%——标准条款、金额、日期、双方信息。但剩余 20% 的关键条款（违约责任、知识产权归属、保密条款）必须人审。AIGC 应做一个"条款风险提示"功能——对每个自动生成的条款打风险分（如违约金比例高于行业标准 2 倍 → 高风险提示），辅助法务快速定位需要重点看的段落。
区块链上存什么、不存什么：只存哈希 + 时间戳 + 签名，不存合同原文。合同原文可能包含商业机密，不适合公开上链。验证时，用户本地持有合同文件，重新计算哈希与链上比对即可。这种方案既满足存证需求，又保护商业隐私。
合同模板的版本管理：AIGC 依赖模板，模板一旦更新（如法律条款调整），之前用旧模板生成的合同和之后用新模板生成的合同可能不一致。模板应该版本化管理（v1.0/v2.0），链上存证时附带模板版本号，方便事后追溯"当时的条款依据是什么版本的模板"。
多签流程的并发：甲方和乙方可能同时签署，链上存证需要处理并发写入。可以使用乐观锁——只有当 contracts 最新状态是 PENDING_SIGN 时才写入 SIGNED。如果状态已被对方修改（如一方签约后另一方拒绝），需要回滚处理。
五、总结
"合同 AIGC 生成 + 区块链存证"的工程价值不在于"替代法务"，而在于"加速非关键环节，聚焦人工审核在关键条款上"。AIGC 负责模板填充（80% 标准内容），法务负责风险审核（20% 关键条款），区块链负责全链路存证（生成、审核、签署三个阶段全部上链）。代码实现上，合同的哈希计算要覆盖完整内容（不能只算模板部分），链上不存原文但存模板版本号，验证链路从"当前内容哈希 → 链上记录"两个点比对。这个方案在新合同法的框架下为电子合同提供了可验证的"原件"证明。
