443 lines
12 KiB
Plaintext
443 lines
12 KiB
Plaintext
///! 跨链模块: 主权跨链协议
|
||
///! NAC的跨链桥接标准协议
|
||
///!
|
||
///! **版本**: v1.0
|
||
///! **模块**: charter-std-zh/sovereignty/cross_chain.ch
|
||
|
||
使用 资产::gnacs::GNACS编码;
|
||
使用 主权::规则::主权类型;
|
||
|
||
// ============================================================================
|
||
// 跨链桥接接口
|
||
// ============================================================================
|
||
|
||
/// 跨链桥接接口
|
||
///
|
||
/// 定义跨链资产转移的标准操作
|
||
接口 跨链桥接 {
|
||
// ========== 查询函数 ==========
|
||
|
||
/// 查询支持的链ID列表
|
||
函数 支持的链() -> 数组<u256>;
|
||
|
||
/// 查询链是否支持
|
||
///
|
||
/// # 参数
|
||
/// - `链ID`: 目标链ID
|
||
函数 是否支持链(链ID: u256) -> 布尔;
|
||
|
||
/// 查询锁定的资产数量
|
||
///
|
||
/// # 参数
|
||
/// - `资产`: 资产地址
|
||
函数 锁定数量(资产: 地址) -> u256;
|
||
|
||
/// 查询用户锁定记录
|
||
///
|
||
/// # 参数
|
||
/// - `用户`: 用户地址
|
||
/// - `锁定ID`: 锁定记录ID
|
||
函数 锁定记录(用户: 地址, 锁定ID: u256) -> 锁定信息;
|
||
|
||
/// 查询跨链手续费
|
||
///
|
||
/// # 参数
|
||
/// - `目标链ID`: 目标链ID
|
||
/// - `资产`: 资产地址
|
||
/// - `数量`: 转移数量
|
||
函数 跨链手续费(目标链ID: u256, 资产: 地址, 数量: u256) -> u256;
|
||
|
||
// ========== 状态变更函数 ==========
|
||
|
||
/// 锁定资产
|
||
///
|
||
/// # 参数
|
||
/// - `资产`: 资产地址
|
||
/// - `数量`: 锁定数量
|
||
/// - `目标链ID`: 目标链ID
|
||
/// - `接收者`: 目标链接收者地址
|
||
///
|
||
/// # 返回
|
||
/// - `u256`: 锁定ID
|
||
///
|
||
/// # 事件
|
||
/// - `资产锁定事件`
|
||
函数 锁定(
|
||
资产: 地址,
|
||
数量: u256,
|
||
目标链ID: u256,
|
||
接收者: 字节数组
|
||
) -> u256;
|
||
|
||
/// 解锁资产
|
||
///
|
||
/// # 参数
|
||
/// - `锁定ID`: 锁定记录ID
|
||
/// - `签名`: 验证者签名数组
|
||
///
|
||
/// # 事件
|
||
/// - `资产解锁事件`
|
||
函数 解锁(
|
||
锁定ID: u256,
|
||
签名: 数组<字节数组>
|
||
);
|
||
|
||
/// 添加支持的链
|
||
///
|
||
/// # 参数
|
||
/// - `链ID`: 链ID
|
||
/// - `链名称`: 链名称
|
||
///
|
||
/// # 事件
|
||
/// - `链添加事件`
|
||
函数 添加链(链ID: u256, 链名称: 字符串);
|
||
|
||
/// 移除支持的链
|
||
///
|
||
/// # 参数
|
||
/// - `链ID`: 链ID
|
||
///
|
||
/// # 事件
|
||
/// - `链移除事件`
|
||
函数 移除链(链ID: u256);
|
||
}
|
||
|
||
// ============================================================================
|
||
// 数据结构定义
|
||
// ============================================================================
|
||
|
||
/// 锁定信息结构
|
||
结构 锁定信息 {
|
||
/// 锁定ID
|
||
ID: u256,
|
||
/// 锁定者
|
||
锁定者: 地址,
|
||
/// 资产地址
|
||
资产: 地址,
|
||
/// 锁定数量
|
||
数量: u256,
|
||
/// 目标链ID
|
||
目标链ID: u256,
|
||
/// 接收者地址（字节数组，支持不同链的地址格式）
|
||
接收者: 字节数组,
|
||
/// 锁定时间
|
||
锁定时间: u256,
|
||
/// 是否已解锁
|
||
已解锁: 布尔
|
||
}
|
||
|
||
/// 链信息结构
|
||
结构 链信息 {
|
||
/// 链ID
|
||
ID: u256,
|
||
/// 链名称
|
||
名称: 字符串,
|
||
/// 是否启用
|
||
启用: 布尔
|
||
}
|
||
|
||
// ============================================================================
|
||
// 跨链事件定义
|
||
// ============================================================================
|
||
|
||
/// 资产锁定事件
|
||
事件 资产锁定事件 {
|
||
锁定ID: u256,
|
||
锁定者: 地址,
|
||
资产: 地址,
|
||
数量: u256,
|
||
目标链ID: u256,
|
||
接收者: 字节数组
|
||
}
|
||
|
||
/// 资产解锁事件
|
||
事件 资产解锁事件 {
|
||
锁定ID: u256,
|
||
接收者: 地址,
|
||
资产: 地址,
|
||
数量: u256
|
||
}
|
||
|
||
/// 链添加事件
|
||
事件 链添加事件 {
|
||
链ID: u256,
|
||
链名称: 字符串
|
||
}
|
||
|
||
/// 链移除事件
|
||
事件 链移除事件 {
|
||
链ID: u256
|
||
}
|
||
|
||
// ============================================================================
|
||
// 跨链桥接基础实现
|
||
// ============================================================================
|
||
|
||
/// 跨链桥接基础实现
|
||
合约 跨链桥接基础 实现 跨链桥接 {
|
||
// ========== 状态变量 ==========
|
||
|
||
私有 _所有者: 地址;
|
||
私有 _支持的链映射: 映射<u256, 链信息>;
|
||
私有 _链ID列表: 数组<u256>;
|
||
私有 _锁定记录映射: 映射<u256, 锁定信息>;
|
||
私有 _用户锁定列表: 映射<地址, 数组<u256>>;
|
||
私有 _资产锁定量: 映射<地址, u256>;
|
||
私有 _下一个锁定ID: u256;
|
||
私有 _手续费率: u256; // 基点，10000=100%
|
||
私有 _最小手续费: u256;
|
||
|
||
// ========== 修饰符 ==========
|
||
|
||
修饰符 仅所有者() {
|
||
要求(消息::发送者() == _所有者, "跨链桥接: 非所有者");
|
||
_;
|
||
}
|
||
|
||
// ========== 构造函数 ==========
|
||
|
||
构造函数(手续费率: u256, 最小手续费: u256) {
|
||
要求(手续费率 <= 10000, "跨链桥接: 手续费率无效");
|
||
|
||
_所有者 = 消息::发送者();
|
||
_手续费率 = 手续费率;
|
||
_最小手续费 = 最小手续费;
|
||
_下一个锁定ID = 0;
|
||
_链ID列表 = 数组::新建();
|
||
}
|
||
|
||
// ========== 查询函数实现 ==========
|
||
|
||
函数 支持的链() -> 数组<u256> {
|
||
返回 _链ID列表;
|
||
}
|
||
|
||
函数 是否支持链(链ID: u256) -> 布尔 {
|
||
如果 !_支持的链映射.包含(链ID) {
|
||
返回 假;
|
||
}
|
||
让 链 = _支持的链映射.获取(链ID);
|
||
返回 链.启用;
|
||
}
|
||
|
||
函数 锁定数量(资产: 地址) -> u256 {
|
||
返回 _资产锁定量.获取或默认(资产, 0);
|
||
}
|
||
|
||
函数 锁定记录(用户: 地址, 锁定ID: u256) -> 锁定信息 {
|
||
要求(_锁定记录映射.包含(锁定ID), "跨链桥接: 锁定记录不存在");
|
||
让 记录 = _锁定记录映射.获取(锁定ID);
|
||
要求(记录.锁定者 == 用户, "跨链桥接: 非锁定者");
|
||
返回 记录;
|
||
}
|
||
|
||
函数 跨链手续费(目标链ID: u256, 资产: 地址, 数量: u256) -> u256 {
|
||
让 手续费 = 数量 * _手续费率 / 10000;
|
||
如果 手续费 < _最小手续费 {
|
||
返回 _最小手续费;
|
||
}
|
||
返回 手续费;
|
||
}
|
||
|
||
// ========== 状态变更函数实现 ==========
|
||
|
||
函数 锁定(
|
||
资产: 地址,
|
||
数量: u256,
|
||
目标链ID: u256,
|
||
接收者: 字节数组
|
||
) -> u256 {
|
||
要求(资产 != 地址::零地址(), "跨链桥接: 资产地址无效");
|
||
要求(数量 > 0, "跨链桥接: 数量无效");
|
||
要求(是否支持链(目标链ID), "跨链桥接: 不支持的链");
|
||
要求(接收者.长度() > 0, "跨链桥接: 接收者地址无效");
|
||
|
||
// 计算手续费
|
||
让 手续费 = 跨链手续费(目标链ID, 资产, 数量);
|
||
让 实际锁定数量 = 数量 - 手续费;
|
||
要求(实际锁定数量 > 0, "跨链桥接: 扣除手续费后数量为零");
|
||
|
||
// 转入资产
|
||
ACC20(资产).转移从(消息::发送者(), 本合约::地址(), 数量);
|
||
|
||
// 创建锁定记录
|
||
让 锁定ID = _下一个锁定ID;
|
||
_下一个锁定ID = _下一个锁定ID + 1;
|
||
|
||
让 记录 = 锁定信息 {
|
||
ID: 锁定ID,
|
||
锁定者: 消息::发送者(),
|
||
资产: 资产,
|
||
数量: 实际锁定数量,
|
||
目标链ID: 目标链ID,
|
||
接收者: 接收者,
|
||
锁定时间: 区块::时间戳(),
|
||
已解锁: 假
|
||
};
|
||
|
||
_锁定记录映射.插入(锁定ID, 记录);
|
||
|
||
// 更新用户锁定列表
|
||
让 可变 用户列表 = _用户锁定列表.获取或默认(消息::发送者(), 数组::新建());
|
||
用户列表.推入(锁定ID);
|
||
_用户锁定列表.插入(消息::发送者(), 用户列表);
|
||
|
||
// 更新资产锁定量
|
||
_资产锁定量.插入(资产, 锁定数量(资产) + 实际锁定数量);
|
||
|
||
触发 资产锁定事件 {
|
||
锁定ID: 锁定ID,
|
||
锁定者: 消息::发送者(),
|
||
资产: 资产,
|
||
数量: 实际锁定数量,
|
||
目标链ID: 目标链ID,
|
||
接收者: 接收者
|
||
};
|
||
|
||
返回 锁定ID;
|
||
}
|
||
|
||
函数 解锁(
|
||
锁定ID: u256,
|
||
签名: 数组<字节数组>
|
||
) {
|
||
要求(_锁定记录映射.包含(锁定ID), "跨链桥接: 锁定记录不存在");
|
||
|
||
让 可变 记录 = _锁定记录映射.获取(锁定ID);
|
||
要求(!记录.已解锁, "跨链桥接: 已解锁");
|
||
|
||
// 验证签名（简化实现）
|
||
要求(签名.长度() >= 3, "跨链桥接: 签名数量不足");
|
||
|
||
// 标记为已解锁
|
||
记录.已解锁 = 真;
|
||
_锁定记录映射.插入(锁定ID, 记录);
|
||
|
||
// 转出资产
|
||
ACC20(记录.资产).转移(记录.锁定者, 记录.数量);
|
||
|
||
// 更新资产锁定量
|
||
_资产锁定量.插入(记录.资产, 锁定数量(记录.资产) - 记录.数量);
|
||
|
||
触发 资产解锁事件 {
|
||
锁定ID: 锁定ID,
|
||
接收者: 记录.锁定者,
|
||
资产: 记录.资产,
|
||
数量: 记录.数量
|
||
};
|
||
}
|
||
|
||
函数 添加链(链ID: u256, 链名称: 字符串) 仅所有者 {
|
||
要求(!_支持的链映射.包含(链ID), "跨链桥接: 链已存在");
|
||
|
||
让 链 = 链信息 {
|
||
ID: 链ID,
|
||
名称: 链名称,
|
||
启用: 真
|
||
};
|
||
|
||
_支持的链映射.插入(链ID, 链);
|
||
_链ID列表.推入(链ID);
|
||
|
||
触发 链添加事件 {
|
||
链ID: 链ID,
|
||
链名称: 链名称
|
||
};
|
||
}
|
||
|
||
函数 移除链(链ID: u256) 仅所有者 {
|
||
要求(_支持的链映射.包含(链ID), "跨链桥接: 链不存在");
|
||
|
||
让 可变 链 = _支持的链映射.获取(链ID);
|
||
链.启用 = 假;
|
||
_支持的链映射.插入(链ID, 链);
|
||
|
||
触发 链移除事件 {
|
||
链ID: 链ID
|
||
};
|
||
}
|
||
}
|
||
|
||
// ============================================================================
|
||
// 跨链消息接口
|
||
// ============================================================================
|
||
|
||
/// 跨链消息接口
|
||
///
|
||
/// 定义跨链消息传递的标准操作
|
||
接口 跨链消息 {
|
||
/// 发送消息
|
||
///
|
||
/// # 参数
|
||
/// - `目标链ID`: 目标链ID
|
||
/// - `接收者`: 接收者地址
|
||
/// - `消息`: 消息内容
|
||
///
|
||
/// # 返回
|
||
/// - `u256`: 消息ID
|
||
函数 发送消息(
|
||
目标链ID: u256,
|
||
接收者: 字节数组,
|
||
消息: 字节数组
|
||
) -> u256;
|
||
|
||
/// 接收消息
|
||
///
|
||
/// # 参数
|
||
/// - `消息ID`: 消息ID
|
||
/// - `发送链ID`: 发送链ID
|
||
/// - `发送者`: 发送者地址
|
||
/// - `消息`: 消息内容
|
||
/// - `签名`: 验证者签名数组
|
||
函数 接收消息(
|
||
消息ID: u256,
|
||
发送链ID: u256,
|
||
发送者: 字节数组,
|
||
消息: 字节数组,
|
||
签名: 数组<字节数组>
|
||
);
|
||
}
|
||
|
||
// ============================================================================
|
||
// 跨链验证器接口
|
||
// ============================================================================
|
||
|
||
/// 跨链验证器接口
|
||
///
|
||
/// 定义跨链验证器的标准操作
|
||
接口 跨链验证器 {
|
||
/// 查询验证器数量
|
||
函数 验证器数量() -> u256;
|
||
|
||
/// 查询是否为验证器
|
||
///
|
||
/// # 参数
|
||
/// - `地址`: 验证器地址
|
||
函数 是否为验证器(地址: 地址) -> 布尔;
|
||
|
||
/// 查询所需签名数量
|
||
函数 所需签名数量() -> u256;
|
||
|
||
/// 添加验证器
|
||
///
|
||
/// # 参数
|
||
/// - `验证器`: 验证器地址
|
||
函数 添加验证器(验证器: 地址);
|
||
|
||
/// 移除验证器
|
||
///
|
||
/// # 参数
|
||
/// - `验证器`: 验证器地址
|
||
函数 移除验证器(验证器: 地址);
|
||
|
||
/// 验证签名
|
||
///
|
||
/// # 参数
|
||
/// - `消息哈希`: 消息哈希
|
||
/// - `签名`: 签名数组
|
||
///
|
||
/// # 返回
|
||
/// - `布尔`: 是否验证通过
|
||
函数 验证签名(消息哈希: 哈希, 签名: 数组<字节数组>) -> 布尔;
|
||
}
|