# 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**