1006 lines
26 KiB
Markdown
1006 lines
26 KiB
Markdown
# Charter语言完整规范（v1.0）
|
||
|
||
**文档版本**: v1.0
|
||
**创建日期**: 2026年2月4日
|
||
**状态**: 草案
|
||
|
||
---
|
||
|
||
## 📋 目录
|
||
|
||
1. [语言概述](#语言概述)
|
||
2. [设计哲学](#设计哲学)
|
||
3. [类型系统](#类型系统)
|
||
4. [语法规范](#语法规范)
|
||
5. [主权规则系统](#主权规则系统)
|
||
6. [标准库](#标准库)
|
||
7. [编译器架构](#编译器架构)
|
||
8. [NVM集成](#nvm集成)
|
||
9. [示例代码](#示例代码)
|
||
10. [与Solidity对比](#与solidity对比)
|
||
|
||
---
|
||
|
||
## 语言概述
|
||
|
||
**Charter**是NAC公链的原生智能合约语言，专为真实世界资产（RWA）的数字化和合规管理而设计。
|
||
|
||
### 核心特性
|
||
|
||
- **合规原生**: 将GNACS资产分类和主权规则内嵌到语言类型系统
|
||
- **声明式**: 以声明合规事实和执行预设规则为核心
|
||
- **类型安全**: 编译期检查资产类型和主权规则
|
||
- **自动化**: 自动生成合规代码和链上登记流程
|
||
- **互操作**: 支持与Solidity合约互操作
|
||
|
||
### 设计目标
|
||
|
||
1. **降低合规成本**: 将法律规则转化为编译期检查
|
||
2. **提高安全性**: 通过类型系统防止非法操作
|
||
3. **简化开发**: 自动生成样板代码和合规流程
|
||
4. **促进标准化**: 统一RWA资产的数字化标准
|
||
|
||
---
|
||
|
||
## 设计哲学
|
||
|
||
### 核心理念
|
||
|
||
> **"将现实世界的资产分类标准与法律主权规则，直接映射为编程语言的类型系统和核心语义。"**
|
||
|
||
### 与传统智能合约语言的区别
|
||
|
||
| 特性 | Solidity/Move | Charter |
|
||
|------|---------------|---------|
|
||
| 核心范式 | 执行业务逻辑 | 声明合规事实 |
|
||
| 类型系统 | 通用类型 | GNACS资产类型 |
|
||
| 规则执行 | 手动编码 | 自动注入 |
|
||
| 合规检查 | 运行时 | 编译期 |
|
||
| 领域专注 | 通用 | RWA专用 |
|
||
|
||
---
|
||
|
||
## 类型系统
|
||
|
||
### 1. 核心类型：Asset<GNACS>
|
||
|
||
所有资产变量必须声明其GNACS编码（48位）。
|
||
|
||
#### 语法
|
||
|
||
```charter
|
||
let <变量名>: Asset<<GNACS编码>> = Asset.new(...);
|
||
```
|
||
|
||
#### 示例
|
||
|
||
```charter
|
||
// 声明一匹纯种繁殖用马资产（GNACS: 010121）
|
||
let raceHorse: Asset<010121> = Asset.new(
|
||
owner: "0x1234...",
|
||
value: 100000.0,
|
||
metadata: {
|
||
breed: "Thoroughbred",
|
||
age: 3,
|
||
gender: "Mare"
|
||
}
|
||
);
|
||
|
||
// 声明一个Bitcoin类资产（GNACS: 990101）
|
||
let btc: Asset<990101> = Asset.new(
|
||
owner: "0x5678...",
|
||
value: 1.5,
|
||
metadata: {
|
||
network: "Bitcoin",
|
||
address: "bc1q..."
|
||
}
|
||
);
|
||
```
|
||
|
||
### 2. GNACS编码结构（48位）
|
||
|
||
```
|
||
位数 | 字段 | 说明
|
||
--------|----------------|------------------
|
||
1-8 | 资产类别 | 9种主要类别
|
||
9-16 | 子类别 | 细分类别
|
||
17-24 | 司法辖区 | 60+司法辖区
|
||
25-28 | 风险等级 | 0-15级
|
||
29-32 | 流动性等级 | 0-15级
|
||
33-36 | 合规状态 | 0-15种状态
|
||
37-40 | 版本号 | 0-15
|
||
41-48 | 保留位 | 未来扩展
|
||
```
|
||
|
||
### 3. 资产实例ID
|
||
|
||
每个Asset实例在创建时，由链上系统自动生成全局唯一的**资产实例ID**：
|
||
|
||
```
|
||
资产实例ID = GNACS编码(48位) + 实例序列号(32位) + 校验码(16位)
|
||
总长度: 96位（12字节）
|
||
```
|
||
|
||
### 4. 条件类型与编译期检查
|
||
|
||
编译器根据GNACS编码自动应用条件编码规则：
|
||
|
||
```charter
|
||
// ✅ 正确：实物资产可以设置物流维度
|
||
let realEstate: Asset<010101> = Asset.new(...);
|
||
realEstate.setLogistics(warehouse: "Dubai Free Zone");
|
||
|
||
// ❌ 错误：数字资产不能设置物流维度（编译期报错）
|
||
let btc: Asset<990101> = Asset.new(...);
|
||
btc.setLogistics(warehouse: "..."); // 编译错误！
|
||
```
|
||
|
||
### 5. 主权类型注解
|
||
|
||
所有合约必须使用`Sovereignty`类型注解明确其主权类别：
|
||
|
||
```charter
|
||
// 定义一个代表"绝对所有权"的房地产合约
|
||
contract RealEstateContract with Sovereignty<A0> {
|
||
// 合约内自动继承《主权法典》中关于A0类主权的所有规则
|
||
}
|
||
```
|
||
|
||
### 6. 主权类别（7种）
|
||
|
||
| 代码 | 名称 | 说明 | 典型应用 |
|
||
|------|------|------|----------|
|
||
| A0 | 绝对所有权 | 完全控制权 | 房地产、艺术品 |
|
||
| B1 | 使用权 | 有期限使用 | 租赁、许可 |
|
||
| C2 | 收益权 | 收益分配权 | 债券、收益权 |
|
||
| D0 | 担保主权 | 抵押担保 | 抵押贷款 |
|
||
| E3 | 知识产权 | 专利、版权 | IP资产 |
|
||
| F4 | 临时监管权 | 托管、监管 | 托管账户 |
|
||
| G5 | 共有权 | 多方共有 | 合伙、共有 |
|
||
|
||
---
|
||
|
||
## 语法规范
|
||
|
||
### 1. 合约定义
|
||
|
||
```charter
|
||
// 基本合约定义
|
||
contract <合约名> with Sovereignty<<主权类别>> {
|
||
// 合约内容
|
||
}
|
||
|
||
// 示例
|
||
contract RealEstateTokenization with Sovereignty<A0> {
|
||
// 状态变量
|
||
let property: Asset<010101>;
|
||
let totalShares: u64 = 1000000;
|
||
|
||
// 构造函数
|
||
constructor(propertyData: PropertyMetadata) {
|
||
self.property = Asset.new(
|
||
owner: msg.sender,
|
||
value: propertyData.appraisalValue,
|
||
metadata: propertyData
|
||
);
|
||
}
|
||
|
||
// 函数
|
||
fn issueShares(recipient: Address, amount: u64) {
|
||
// 函数实现
|
||
}
|
||
}
|
||
```
|
||
|
||
### 2. 规则修饰符
|
||
|
||
将《主权法典》中的具体规则实现为语言内置的规则修饰符：
|
||
|
||
```charter
|
||
// 定义一个"抵押"操作
|
||
// #[Rule(D0)] 表示此函数必须遵守《主权法典》中D0（担保主权）的所有规则
|
||
#[Rule(D0)]
|
||
fn create_mortgage(asset: Asset<010121>, beneficiary: Address, amount: u256) {
|
||
// 编译器会自动在此插入：
|
||
// 1. 检查asset当前是否无其他更高优先级权利冲突
|
||
// 2. 生成符合D0类主权要求的抵押登记数据
|
||
// 3. 自动触发链上登记流程
|
||
|
||
// 开发者只需关注业务参数
|
||
let mortgage = Mortgage.new(
|
||
asset: asset,
|
||
beneficiary: beneficiary,
|
||
amount: amount,
|
||
term: 365 * 24 * 3600 // 1年
|
||
);
|
||
|
||
// 自动登记
|
||
Registry.register(mortgage);
|
||
}
|
||
```
|
||
|
||
### 3. 函数定义
|
||
|
||
```charter
|
||
// 公开函数
|
||
pub fn <函数名>(<参数列表>) -> <返回类型> {
|
||
// 函数体
|
||
}
|
||
|
||
// 私有函数
|
||
fn <函数名>(<参数列表>) -> <返回类型> {
|
||
// 函数体
|
||
}
|
||
|
||
// 带规则修饰符的函数
|
||
#[Rule(<主权类别>)]
|
||
fn <函数名>(<参数列表>) -> <返回类型> {
|
||
// 函数体
|
||
}
|
||
|
||
// 示例
|
||
pub fn transfer(from: Address, to: Address, asset: Asset<010101>) -> bool {
|
||
require(asset.owner == from, "Not owner");
|
||
asset.owner = to;
|
||
emit Transfer(from, to, asset.id);
|
||
return true;
|
||
}
|
||
```
|
||
|
||
### 4. 变量声明
|
||
|
||
```charter
|
||
// 不可变变量
|
||
let <变量名>: <类型> = <初始值>;
|
||
|
||
// 可变变量
|
||
let mut <变量名>: <类型> = <初始值>;
|
||
|
||
// 示例
|
||
let totalSupply: u256 = 1000000;
|
||
let mut balance: u256 = 0;
|
||
let asset: Asset<010101> = Asset.new(...);
|
||
```
|
||
|
||
### 5. 控制流
|
||
|
||
```charter
|
||
// if-else
|
||
if <条件> {
|
||
// 代码块
|
||
} else if <条件> {
|
||
// 代码块
|
||
} else {
|
||
// 代码块
|
||
}
|
||
|
||
// for循环
|
||
for <变量> in <迭代器> {
|
||
// 代码块
|
||
}
|
||
|
||
// while循环
|
||
while <条件> {
|
||
// 代码块
|
||
}
|
||
|
||
// match表达式
|
||
match <表达式> {
|
||
<模式1> => <表达式1>,
|
||
<模式2> => <表达式2>,
|
||
_ => <默认表达式>
|
||
}
|
||
```
|
||
|
||
### 6. 事件定义
|
||
|
||
```charter
|
||
// 事件定义
|
||
event <事件名>(<参数列表>);
|
||
|
||
// 示例
|
||
event Transfer(from: Address, to: Address, assetId: u256);
|
||
event Approval(owner: Address, spender: Address, assetId: u256);
|
||
event Mortgage(assetId: u256, beneficiary: Address, amount: u256);
|
||
|
||
// 触发事件
|
||
emit Transfer(from, to, assetId);
|
||
```
|
||
|
||
---
|
||
|
||
## 主权规则系统
|
||
|
||
### 1. 规则库结构
|
||
|
||
```charter
|
||
// 主权规则库（内置）
|
||
namespace SovereigntyRules {
|
||
// A0: 绝对所有权规则
|
||
rule A0 {
|
||
// 自由处置
|
||
allow transfer(asset: Asset, to: Address);
|
||
allow sell(asset: Asset, price: u256);
|
||
allow destroy(asset: Asset);
|
||
|
||
// 无期限限制
|
||
no_expiration: true;
|
||
|
||
// 可抵押
|
||
allow mortgage(asset: Asset, amount: u256);
|
||
}
|
||
|
||
// B1: 使用权规则
|
||
rule B1 {
|
||
// 有期限限制
|
||
require expiration: Timestamp;
|
||
|
||
// 不可转让（除非合约明确允许）
|
||
deny transfer(asset: Asset, to: Address);
|
||
|
||
// 到期自动回收
|
||
on_expiration: auto_return_to_owner;
|
||
}
|
||
|
||
// C2: 收益权规则
|
||
rule C2 {
|
||
// 只能收取收益
|
||
allow claim_revenue(asset: Asset) -> u256;
|
||
|
||
// 不能处置资产本身
|
||
deny transfer(asset: Asset, to: Address);
|
||
deny sell(asset: Asset, price: u256);
|
||
|
||
// 收益分配规则
|
||
require revenue_distribution: RevenueDistribution;
|
||
}
|
||
|
||
// D0: 担保主权规则
|
||
rule D0 {
|
||
// 必须有抵押物
|
||
require collateral: Asset;
|
||
|
||
// 必须有受益人
|
||
require beneficiary: Address;
|
||
|
||
// 必须有抵押金额
|
||
require amount: u256;
|
||
|
||
// 必须有期限
|
||
require term: Duration;
|
||
|
||
// 清算规则
|
||
on_default: liquidate_collateral;
|
||
}
|
||
|
||
// E3: 知识产权规则
|
||
rule E3 {
|
||
// 必须有许可条款
|
||
require license_terms: LicenseTerms;
|
||
|
||
// 可授权使用
|
||
allow grant_license(licensee: Address, terms: LicenseTerms);
|
||
|
||
// 可收取许可费
|
||
allow collect_royalty() -> u256;
|
||
}
|
||
|
||
// F4: 临时监管权规则
|
||
rule F4 {
|
||
// 必须有原所有者
|
||
require original_owner: Address;
|
||
|
||
// 必须有监管期限
|
||
require custody_period: Duration;
|
||
|
||
// 到期归还
|
||
on_expiration: return_to_original_owner;
|
||
|
||
// 监管期间不可转让
|
||
deny transfer(asset: Asset, to: Address);
|
||
}
|
||
|
||
// G5: 共有权规则
|
||
rule G5 {
|
||
// 必须有共有人列表
|
||
require co_owners: Vec<Address>;
|
||
|
||
// 必须有份额分配
|
||
require ownership_shares: Map<Address, u256>;
|
||
|
||
// 重大决策需要多数同意
|
||
require majority_consent: bool;
|
||
|
||
// 收益按份额分配
|
||
on_revenue: distribute_by_shares;
|
||
}
|
||
}
|
||
```
|
||
|
||
### 2. 规则应用
|
||
|
||
```charter
|
||
// 应用规则到合约
|
||
contract MortgageContract with Sovereignty<D0> {
|
||
// 自动继承D0规则
|
||
// 编译器会自动检查是否满足D0规则的所有要求
|
||
|
||
let collateral: Asset<010101>; // 必须
|
||
let beneficiary: Address; // 必须
|
||
let amount: u256; // 必须
|
||
let term: Duration; // 必须
|
||
|
||
// 违反规则会导致编译错误
|
||
}
|
||
|
||
// 应用规则到函数
|
||
#[Rule(D0)]
|
||
fn create_mortgage(
|
||
collateral: Asset<010101>,
|
||
beneficiary: Address,
|
||
amount: u256,
|
||
term: Duration
|
||
) {
|
||
// 编译器自动注入D0规则检查代码
|
||
// 1. 检查collateral是否无其他权利冲突
|
||
// 2. 生成抵押登记数据
|
||
// 3. 触发链上登记流程
|
||
// 4. 设置清算条件
|
||
|
||
// 开发者代码
|
||
let mortgage = Mortgage {
|
||
collateral: collateral,
|
||
beneficiary: beneficiary,
|
||
amount: amount,
|
||
term: term,
|
||
created_at: block.timestamp
|
||
};
|
||
|
||
// 自动登记
|
||
Registry.register(mortgage);
|
||
}
|
||
```
|
||
|
||
---
|
||
|
||
## 标准库
|
||
|
||
### 1. 标准库架构
|
||
|
||
```
|
||
charter-std/
|
||
├── asset/ # 资产相关
|
||
│ ├── gnacs.ch # GNACS类型系统
|
||
│ ├── metadata.ch # 元数据管理
|
||
│ └── lifecycle.ch# 资产生命周期
|
||
├── sovereignty/ # 主权规则
|
||
│ ├── rules.ch # 规则定义
|
||
│ ├── registry.ch # 登记系统
|
||
│ └── compliance.ch# 合规检查
|
||
├── acc/ # ACC协议
|
||
│ ├── acc20.ch # 可替代资产
|
||
│ ├── acc721.ch # 唯一资产
|
||
│ └── acc1155.ch # 多类型资产
|
||
├── defi/ # DeFi模块
|
||
│ ├── marketplace.ch# 交易市场
|
||
│ ├── lending.ch # 借贷
|
||
│ └── liquidity.ch# 流动性池
|
||
├── governance/ # 治理模块
|
||
│ ├── voting.ch # 投票
|
||
│ └── proposal.ch # 提案
|
||
└── utils/ # 工具函数
|
||
├── math.ch # 数学运算
|
||
├── crypto.ch # 加密函数
|
||
└── string.ch # 字符串处理
|
||
```
|
||
|
||
### 2. 标准库示例
|
||
|
||
#### GNACS类型系统
|
||
|
||
```charter
|
||
// charter-std/asset/gnacs.ch
|
||
|
||
// GNACS编码结构
|
||
struct GNACSCode {
|
||
asset_class: u8, // 资产类别（8位）
|
||
sub_class: u8, // 子类别（8位）
|
||
jurisdiction: u8, // 司法辖区（8位）
|
||
risk_level: u4, // 风险等级（4位）
|
||
liquidity_level: u4, // 流动性等级（4位）
|
||
compliance_status: u4,// 合规状态（4位）
|
||
version: u4, // 版本号（4位）
|
||
reserved: u8 // 保留位（8位）
|
||
}
|
||
|
||
// GNACS编码解析
|
||
impl GNACSCode {
|
||
// 从48位整数解析
|
||
pub fn from_u48(code: u48) -> GNACSCode {
|
||
GNACSCode {
|
||
asset_class: (code >> 40) as u8,
|
||
sub_class: ((code >> 32) & 0xFF) as u8,
|
||
jurisdiction: ((code >> 24) & 0xFF) as u8,
|
||
risk_level: ((code >> 20) & 0x0F) as u4,
|
||
liquidity_level: ((code >> 16) & 0x0F) as u4,
|
||
compliance_status: ((code >> 12) & 0x0F) as u4,
|
||
version: ((code >> 8) & 0x0F) as u4,
|
||
reserved: (code & 0xFF) as u8
|
||
}
|
||
}
|
||
|
||
// 转换为48位整数
|
||
pub fn to_u48(&self) -> u48 {
|
||
((self.asset_class as u48) << 40) |
|
||
((self.sub_class as u48) << 32) |
|
||
((self.jurisdiction as u48) << 24) |
|
||
((self.risk_level as u48) << 20) |
|
||
((self.liquidity_level as u48) << 16) |
|
||
((self.compliance_status as u48) << 12) |
|
||
((self.version as u48) << 8) |
|
||
(self.reserved as u48)
|
||
}
|
||
|
||
// 验证编码有效性
|
||
pub fn validate(&self) -> bool {
|
||
// 检查资产类别是否有效（1-9）
|
||
if self.asset_class < 1 || self.asset_class > 9 {
|
||
return false;
|
||
}
|
||
|
||
// 检查风险等级是否有效（0-15）
|
||
if self.risk_level > 15 {
|
||
return false;
|
||
}
|
||
|
||
// 检查流动性等级是否有效（0-15）
|
||
if self.liquidity_level > 15 {
|
||
return false;
|
||
}
|
||
|
||
return true;
|
||
}
|
||
}
|
||
|
||
// 资产类别常量
|
||
const REAL_ESTATE: u8 = 1; // 不动产
|
||
const FINANCIAL_ASSETS: u8 = 2; // 金融资产
|
||
const ART_COLLECTIBLES: u8 = 3; // 艺术品
|
||
const COMMODITIES: u8 = 4; // 大宗商品
|
||
const INTELLECTUAL_PROPERTY: u8 = 5; // 知识产权
|
||
const CARBON_CREDITS: u8 = 6; // 碳信用
|
||
const DIGITAL_ASSETS: u8 = 7; // 数字资产
|
||
const REVENUE_RIGHTS: u8 = 8; // 收益权
|
||
const OTHER: u8 = 9; // 其他
|
||
```
|
||
|
||
#### ACC-20协议
|
||
|
||
```charter
|
||
// charter-std/acc/acc20.ch
|
||
|
||
// ACC-20可替代资产协议
|
||
interface ACC20 {
|
||
// 查询总供应量
|
||
fn totalSupply() -> u256;
|
||
|
||
// 查询余额
|
||
fn balanceOf(owner: Address) -> u256;
|
||
|
||
// 转账
|
||
fn transfer(to: Address, amount: u256) -> bool;
|
||
|
||
// 授权
|
||
fn approve(spender: Address, amount: u256) -> bool;
|
||
|
||
// 查询授权额度
|
||
fn allowance(owner: Address, spender: Address) -> u256;
|
||
|
||
// 从授权额度转账
|
||
fn transferFrom(from: Address, to: Address, amount: u256) -> bool;
|
||
|
||
// 事件
|
||
event Transfer(from: Address, to: Address, amount: u256);
|
||
event Approval(owner: Address, spender: Address, amount: u256);
|
||
}
|
||
|
||
// ACC-20标准实现
|
||
contract ACC20Token with Sovereignty<A0> implements ACC20 {
|
||
let mut totalSupply: u256;
|
||
let mut balances: Map<Address, u256>;
|
||
let mut allowances: Map<Address, Map<Address, u256>>;
|
||
|
||
constructor(initialSupply: u256) {
|
||
self.totalSupply = initialSupply;
|
||
self.balances[msg.sender] = initialSupply;
|
||
}
|
||
|
||
pub fn totalSupply() -> u256 {
|
||
return self.totalSupply;
|
||
}
|
||
|
||
pub fn balanceOf(owner: Address) -> u256 {
|
||
return self.balances[owner];
|
||
}
|
||
|
||
pub fn transfer(to: Address, amount: u256) -> bool {
|
||
require(self.balances[msg.sender] >= amount, "Insufficient balance");
|
||
self.balances[msg.sender] -= amount;
|
||
self.balances[to] += amount;
|
||
emit Transfer(msg.sender, to, amount);
|
||
return true;
|
||
}
|
||
|
||
pub fn approve(spender: Address, amount: u256) -> bool {
|
||
self.allowances[msg.sender][spender] = amount;
|
||
emit Approval(msg.sender, spender, amount);
|
||
return true;
|
||
}
|
||
|
||
pub fn allowance(owner: Address, spender: Address) -> u256 {
|
||
return self.allowances[owner][spender];
|
||
}
|
||
|
||
pub fn transferFrom(from: Address, to: Address, amount: u256) -> bool {
|
||
require(self.balances[from] >= amount, "Insufficient balance");
|
||
require(self.allowances[from][msg.sender] >= amount, "Insufficient allowance");
|
||
|
||
self.balances[from] -= amount;
|
||
self.balances[to] += amount;
|
||
self.allowances[from][msg.sender] -= amount;
|
||
|
||
emit Transfer(from, to, amount);
|
||
return true;
|
||
}
|
||
}
|
||
```
|
||
|
||
---
|
||
|
||
## 编译器架构
|
||
|
||
### 1. 编译流程
|
||
|
||
```
|
||
源代码(.ch)
|
||
↓
|
||
词法分析（Lexer）
|
||
↓
|
||
Token流
|
||
↓
|
||
语法分析（Parser）
|
||
↓
|
||
抽象语法树（AST）
|
||
↓
|
||
语义分析（Semantic Analyzer）
|
||
↓
|
||
类型检查（Type Checker）
|
||
↓
|
||
GNACS验证（GNACS Validator）
|
||
↓
|
||
主权规则注入（Rule Injector）
|
||
↓
|
||
中间表示（IR）
|
||
↓
|
||
优化（Optimizer）
|
||
↓
|
||
NVM字节码生成（Bytecode Generator）
|
||
↓
|
||
NVM字节码(.nvmbc)
|
||
```
|
||
|
||
### 2. 编译器模块
|
||
|
||
```
|
||
charter-compiler/
|
||
├── lexer/ # 词法分析器
|
||
│ ├── token.rs # Token定义
|
||
│ └── scanner.rs # 扫描器
|
||
├── parser/ # 语法分析器
|
||
│ ├── ast.rs # AST定义
|
||
│ └── parser.rs # 解析器
|
||
├── semantic/ # 语义分析器
|
||
│ ├── analyzer.rs # 分析器
|
||
│ └── symbol_table.rs # 符号表
|
||
├── typechecker/ # 类型检查器
|
||
│ ├── checker.rs # 检查器
|
||
│ └── gnacs_validator.rs # GNACS验证
|
||
├── rule_injector/ # 规则注入器
|
||
│ ├── injector.rs # 注入器
|
||
│ └── rules.rs # 规则库
|
||
├── ir/ # 中间表示
|
||
│ ├── ir.rs # IR定义
|
||
│ └── builder.rs # IR构建器
|
||
├── optimizer/ # 优化器
|
||
│ ├── optimizer.rs# 优化器
|
||
│ └── passes.rs # 优化pass
|
||
└── codegen/ # 代码生成器
|
||
├── nvm_codegen.rs # NVM代码生成
|
||
└── bytecode.rs # 字节码定义
|
||
```
|
||
|
||
---
|
||
|
||
## NVM集成
|
||
|
||
### 1. Charter到NVM操作码映射
|
||
|
||
| Charter操作 | NVM操作码 | 说明 |
|
||
|------------|-----------|------|
|
||
| Asset.new() | CREATE_ASSET | 创建资产 |
|
||
| asset.transfer() | TRANSFER_ASSET | 转移资产 |
|
||
| asset.owner | GET_OWNER | 获取所有者 |
|
||
| asset.value | GET_VALUE | 获取价值 |
|
||
| Registry.register() | REGISTER_ASSET | 登记资产 |
|
||
| emit Event() | EMIT_EVENT | 触发事件 |
|
||
| require() | REQUIRE | 断言检查 |
|
||
|
||
### 2. 字节码格式
|
||
|
||
```
|
||
NVM字节码格式：
|
||
+------------------+
|
||
| Magic Number (4) | # 0x4E564D43 ("NVMC")
|
||
+------------------+
|
||
| Version (2) | # 编译器版本
|
||
+------------------+
|
||
| Code Size (4) | # 代码段大小
|
||
+------------------+
|
||
| Data Size (4) | # 数据段大小
|
||
+------------------+
|
||
| Code Section | # 代码段
|
||
+------------------+
|
||
| Data Section | # 数据段
|
||
+------------------+
|
||
| Metadata Section | # 元数据段
|
||
+------------------+
|
||
```
|
||
|
||
---
|
||
|
||
## 示例代码
|
||
|
||
### 示例1：纯种马资产代币化
|
||
|
||
```charter
|
||
// 纯种马资产代币化合约
|
||
contract RaceHorseTokenization with Sovereignty<C2> {
|
||
// 资产声明
|
||
let horse: Asset<010121>; // GNACS: 010121 = 纯种繁殖用马
|
||
let totalShares: u64 = 1000000; // 100万份
|
||
let mut issuedShares: u64 = 0;
|
||
|
||
// 构造函数
|
||
constructor(horseData: HorseMetadata) {
|
||
self.horse = Asset.new(
|
||
owner: msg.sender,
|
||
value: horseData.appraisalValue,
|
||
metadata: horseData
|
||
);
|
||
|
||
// 自动触发XTZH质押（100%质押，80%发行）
|
||
// 编译器自动注入
|
||
}
|
||
|
||
// 发行收益权代币
|
||
#[Rule(C2)]
|
||
pub fn issueShares(recipient: Address, amount: u64) -> bool {
|
||
require(issuedShares + amount <= totalShares, "Exceeds total shares");
|
||
require(horse.owner == msg.sender, "Not owner");
|
||
|
||
// 自动创建ACC-20代币
|
||
// 编译器自动注入
|
||
|
||
issuedShares += amount;
|
||
emit SharesIssued(recipient, amount);
|
||
return true;
|
||
}
|
||
|
||
// 分配收益
|
||
#[Rule(C2)]
|
||
pub fn distributeRevenue(totalRevenue: u256) {
|
||
// 自动按份额分配
|
||
// 编译器自动注入
|
||
|
||
emit RevenueDistributed(totalRevenue);
|
||
}
|
||
|
||
// 事件
|
||
event SharesIssued(recipient: Address, amount: u64);
|
||
event RevenueDistributed(totalRevenue: u256);
|
||
}
|
||
```
|
||
|
||
### 示例2：房地产抵押贷款
|
||
|
||
```charter
|
||
// 房地产抵押贷款合约
|
||
contract RealEstateMortgage with Sovereignty<D0> {
|
||
// 抵押物
|
||
let collateral: Asset<010101>; // GNACS: 010101 = 住宅房地产
|
||
|
||
// 贷款信息
|
||
let beneficiary: Address;
|
||
let loanAmount: u256;
|
||
let interestRate: u256; // 年利率（基点）
|
||
let term: Duration; // 贷款期限
|
||
let startTime: Timestamp;
|
||
|
||
// 状态
|
||
let mut isPaid: bool = false;
|
||
let mut isDefaulted: bool = false;
|
||
|
||
// 构造函数
|
||
constructor(
|
||
_collateral: Asset<010101>,
|
||
_beneficiary: Address,
|
||
_loanAmount: u256,
|
||
_interestRate: u256,
|
||
_term: Duration
|
||
) {
|
||
self.collateral = _collateral;
|
||
self.beneficiary = _beneficiary;
|
||
self.loanAmount = _loanAmount;
|
||
self.interestRate = _interestRate;
|
||
self.term = _term;
|
||
self.startTime = block.timestamp;
|
||
|
||
// 自动登记抵押
|
||
// 编译器自动注入D0规则检查和登记流程
|
||
}
|
||
|
||
// 还款
|
||
#[Rule(D0)]
|
||
pub fn repay() payable {
|
||
require(!isPaid, "Already paid");
|
||
require(!isDefaulted, "Loan defaulted");
|
||
|
||
let totalAmount = calculateTotalAmount();
|
||
require(msg.value >= totalAmount, "Insufficient payment");
|
||
|
||
// 转账给受益人
|
||
beneficiary.transfer(totalAmount);
|
||
|
||
// 解除抵押
|
||
// 编译器自动注入解除抵押流程
|
||
|
||
isPaid = true;
|
||
emit LoanRepaid(msg.sender, totalAmount);
|
||
}
|
||
|
||
// 清算
|
||
#[Rule(D0)]
|
||
pub fn liquidate() {
|
||
require(!isPaid, "Already paid");
|
||
require(block.timestamp > startTime + term, "Not yet due");
|
||
|
||
// 自动清算抵押物
|
||
// 编译器自动注入清算流程
|
||
|
||
isDefaulted = true;
|
||
emit Liquidated(collateral.id, beneficiary);
|
||
}
|
||
|
||
// 计算总还款额
|
||
fn calculateTotalAmount() -> u256 {
|
||
let principal = loanAmount;
|
||
let interest = (loanAmount * interestRate * term.years()) / 10000;
|
||
return principal + interest;
|
||
}
|
||
|
||
// 事件
|
||
event LoanRepaid(borrower: Address, amount: u256);
|
||
event Liquidated(assetId: u256, beneficiary: Address);
|
||
}
|
||
```
|
||
|
||
---
|
||
|
||
## 与Solidity对比
|
||
|
||
### 代码对比：ERC-20 vs ACC-20
|
||
|
||
#### Solidity (ERC-20)
|
||
|
||
```solidity
|
||
// SPDX-License-Identifier: MIT
|
||
pragma solidity ^0.8.0;
|
||
|
||
contract ERC20Token {
|
||
string public name;
|
||
string public symbol;
|
||
uint8 public decimals;
|
||
uint256 public totalSupply;
|
||
|
||
mapping(address => uint256) public balanceOf;
|
||
mapping(address => mapping(address => uint256)) public allowance;
|
||
|
||
event Transfer(address indexed from, address indexed to, uint256 value);
|
||
event Approval(address indexed owner, address indexed spender, uint256 value);
|
||
|
||
constructor(string memory _name, string memory _symbol, uint256 _totalSupply) {
|
||
name = _name;
|
||
symbol = _symbol;
|
||
decimals = 18;
|
||
totalSupply = _totalSupply;
|
||
balanceOf[msg.sender] = _totalSupply;
|
||
}
|
||
|
||
function transfer(address to, uint256 value) public returns (bool) {
|
||
require(balanceOf[msg.sender] >= value, "Insufficient balance");
|
||
balanceOf[msg.sender] -= value;
|
||
balanceOf[to] += value;
|
||
emit Transfer(msg.sender, to, value);
|
||
return true;
|
||
}
|
||
|
||
function approve(address spender, uint256 value) public returns (bool) {
|
||
allowance[msg.sender][spender] = value;
|
||
emit Approval(msg.sender, spender, value);
|
||
return true;
|
||
}
|
||
|
||
function transferFrom(address from, address to, uint256 value) public returns (bool) {
|
||
require(balanceOf[from] >= value, "Insufficient balance");
|
||
require(allowance[from][msg.sender] >= value, "Insufficient allowance");
|
||
balanceOf[from] -= value;
|
||
balanceOf[to] += value;
|
||
allowance[from][msg.sender] -= value;
|
||
emit Transfer(from, to, value);
|
||
return true;
|
||
}
|
||
}
|
||
```
|
||
|
||
#### Charter (ACC-20)
|
||
|
||
```charter
|
||
// Charter版本 - 更简洁，自动合规
|
||
contract ACC20Token with Sovereignty<A0> implements ACC20 {
|
||
constructor(initialSupply: u256) {
|
||
// 自动初始化totalSupply和balances
|
||
// 编译器自动注入
|
||
}
|
||
|
||
// 其他函数由ACC20接口自动实现
|
||
// 编译器自动注入标准实现
|
||
}
|
||
```
|
||
|
||
**对比总结**:
|
||
- Solidity: 100+行代码
|
||
- Charter: 10行代码
|
||
- Charter自动处理：状态变量、事件、标准函数实现、合规检查
|
||
|
||
---
|
||
|
||
## 总结
|
||
|
||
Charter语言是NAC公链的核心创新之一，它通过将RWA领域的专业知识内嵌到语言设计中，大幅降低了开发门槛和合规成本，提高了代码安全性和可维护性。
|
||
|
||
### 核心优势
|
||
|
||
1. **合规自动化**: 编译期检查，运行时保障
|
||
2. **开发效率**: 代码量减少80%+
|
||
3. **类型安全**: GNACS类型系统防止错误
|
||
4. **标准化**: 统一RWA资产数字化标准
|
||
5. **互操作**: 支持与Solidity合约互操作
|
||
|
||
### 下一步
|
||
|
||
1. 实现Charter编译器核心
|
||
2. 开发Charter标准库
|
||
3. 集成到NVM
|
||
4. 开发Charter Playground
|
||
5. 社区推广和生态建设
|
||
|
||
---
|
||
|
||
**文档版本**: v1.0
|
||
**最后更新**: 2026年2月4日
|
||
**状态**: 草案
|
||
|
||
---
|
||
|
||
**END OF DOCUMENT**
|