26 KiB

Raw Permalink Blame History

Charter语言完整规范（v1.0）

文档版本: v1.0
创建日期: 2026年2月4日
状态: 草案

📋 目录

语言概述
设计哲学
类型系统
语法规范
主权规则系统
标准库
编译器架构
NVM集成
示例代码
与Solidity对比

语言概述

Charter是NAC公链的原生智能合约语言，专为真实世界资产（RWA）的数字化和合规管理而设计。

核心特性

合规原生: 将GNACS资产分类和主权规则内嵌到语言类型系统
声明式: 以声明合规事实和执行预设规则为核心
类型安全: 编译期检查资产类型和主权规则
自动化: 自动生成合规代码和链上登记流程
互操作: 支持与Solidity合约互操作

设计目标

降低合规成本: 将法律规则转化为编译期检查
提高安全性: 通过类型系统防止非法操作
简化开发: 自动生成样板代码和合规流程
促进标准化: 统一RWA资产的数字化标准

设计哲学

核心理念

"将现实世界的资产分类标准与法律主权规则，直接映射为编程语言的类型系统和核心语义。"

与传统智能合约语言的区别

特性	Solidity/Move	Charter
核心范式	执行业务逻辑	声明合规事实
类型系统	通用类型	GNACS资产类型
规则执行	手动编码	自动注入
合规检查	运行时	编译期
领域专注	通用	RWA专用

类型系统

1. 核心类型：Asset

所有资产变量必须声明其GNACS编码（48位）。

语法

let <变量名>: Asset<<GNACS编码>> = Asset.new(...);

示例

// 声明一匹纯种繁殖用马资产（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编码自动应用条件编码规则：

// ✅ 正确：实物资产可以设置物流维度
let realEstate: Asset<010101> = Asset.new(...);
realEstate.setLogistics(warehouse: "Dubai Free Zone");

// ❌ 错误：数字资产不能设置物流维度（编译期报错）
let btc: Asset<990101> = Asset.new(...);
btc.setLogistics(warehouse: "..."); // 编译错误！

5. 主权类型注解

所有合约必须使用Sovereignty类型注解明确其主权类别：

// 定义一个代表"绝对所有权"的房地产合约
contract RealEstateContract with Sovereignty<A0> {
    // 合约内自动继承《主权法典》中关于A0类主权的所有规则
}

6. 主权类别（7种）

代码	名称	说明	典型应用
A0	绝对所有权	完全控制权	房地产、艺术品
B1	使用权	有期限使用	租赁、许可
C2	收益权	收益分配权	债券、收益权
D0	担保主权	抵押担保	抵押贷款
E3	知识产权	专利、版权	IP资产
F4	临时监管权	托管、监管	托管账户
G5	共有权	多方共有	合伙、共有

语法规范

1. 合约定义

// 基本合约定义
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. 规则修饰符

将《主权法典》中的具体规则实现为语言内置的规则修饰符：

// 定义一个"抵押"操作
// #[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. 函数定义

// 公开函数
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. 变量声明

// 不可变变量
let <变量名>: <类型> = <初始值>;

// 可变变量
let mut <变量名>: <类型> = <初始值>;

// 示例
let totalSupply: u256 = 1000000;
let mut balance: u256 = 0;
let asset: Asset<010101> = Asset.new(...);

5. 控制流

// if-else
if <条件> {
    // 代码块
} else if <条件> {
    // 代码块
} else {
    // 代码块
}

// for循环
for <变量> in <迭代器> {
    // 代码块
}

// while循环
while <条件> {
    // 代码块
}

// match表达式
match <表达式> {
    <模式1> => <表达式1>,
    <模式2> => <表达式2>,
    _ => <默认表达式>
}

6. 事件定义

// 事件定义
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. 规则库结构

// 主权规则库（内置）
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. 规则应用

// 应用规则到合约
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-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-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：纯种马资产代币化

// 纯种马资产代币化合约
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：房地产抵押贷款

// 房地产抵押贷款合约
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)

// 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版本 - 更简洁，自动合规
contract ACC20Token with Sovereignty<A0> implements ACC20 {
    constructor(initialSupply: u256) {
        // 自动初始化totalSupply和balances
        // 编译器自动注入
    }
    
    // 其他函数由ACC20接口自动实现
    // 编译器自动注入标准实现
}

对比总结:

Solidity: 100+行代码
Charter: 10行代码
Charter自动处理：状态变量、事件、标准函数实现、合规检查

总结

Charter语言是NAC公链的核心创新之一，它通过将RWA领域的专业知识内嵌到语言设计中，大幅降低了开发门槛和合规成本，提高了代码安全性和可维护性。

核心优势

合规自动化: 编译期检查，运行时保障
开发效率: 代码量减少80%+
类型安全: GNACS类型系统防止错误
标准化: 统一RWA资产数字化标准
互操作: 支持与Solidity合约互操作

下一步

实现Charter编译器核心
开发Charter标准库
集成到NVM
开发Charter Playground
社区推广和生态建设

文档版本: v1.0
最后更新: 2026年2月4日
状态: 草案

END OF DOCUMENT

26 KiB Raw Permalink Blame History Unescape Escape