532 lines
15 KiB
Rust
532 lines
15 KiB
Rust
// ACC-RWA: 真实世界资产协议（Real World Asset Protocol）
|
||
//
|
||
// NAC原生的RWA资产标准，专为真实世界资产上链设计
|
||
// 100% NAC原生协议，不是任何现有标准的实现
|
||
|
||
use serde::{Deserialize, Serialize};
|
||
use std::collections::HashMap;
|
||
|
||
/// RWA资产类型
|
||
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
|
||
pub enum RWAAssetType {
|
||
/// 不动产（房地产、土地）
|
||
RealEstate,
|
||
/// 贵金属（黄金、白银、铂金）
|
||
PreciousMetal,
|
||
/// 艺术品（绘画、雕塑、古董）
|
||
Artwork,
|
||
/// 股权（公司股权、基金份额）
|
||
Equity,
|
||
/// 债券（政府债券、企业债券）
|
||
Bond,
|
||
/// 大宗商品（石油、天然气、农产品）
|
||
Commodity,
|
||
/// 知识产权（专利、商标、版权）
|
||
IntellectualProperty,
|
||
/// 收藏品（邮票、钱币、珠宝）
|
||
Collectible,
|
||
/// 其他
|
||
Other(String),
|
||
}
|
||
|
||
/// RWA资产状态
|
||
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
|
||
pub enum RWAAssetStatus {
|
||
/// 待审核
|
||
Pending,
|
||
/// 已激活
|
||
Active,
|
||
/// 已冻结
|
||
Frozen,
|
||
/// 已注销
|
||
Deactivated,
|
||
}
|
||
|
||
/// RWA资产信息
|
||
#[derive(Debug, Clone, Serialize, Deserialize)]
|
||
pub struct RWAAssetInfo {
|
||
/// 资产ID
|
||
pub asset_id: String,
|
||
/// 资产类型
|
||
pub asset_type: RWAAssetType,
|
||
/// 资产名称
|
||
pub name: String,
|
||
/// 资产描述
|
||
pub description: String,
|
||
/// 资产DNA（NAC原生，简化为String）
|
||
pub asset_dna: String,
|
||
/// GNACS分类编码（NAC原生）
|
||
pub gnacs_code: String,
|
||
/// 所有者地址
|
||
pub owner: String,
|
||
/// 估值（USD，以分为单位）
|
||
pub valuation_usd: u128,
|
||
/// 资产状态
|
||
pub status: RWAAssetStatus,
|
||
/// 物理位置
|
||
pub physical_location: Option<String>,
|
||
/// 法律文件哈希列表（简化为String列表）
|
||
pub legal_documents: Vec<String>,
|
||
/// 创建时间（Unix时间戳）
|
||
pub created_at: u64,
|
||
/// 更新时间（Unix时间戳）
|
||
pub updated_at: u64,
|
||
/// 最后审计时间
|
||
pub last_audited_at: Option<u64>,
|
||
}
|
||
|
||
/// RWA资产错误类型
|
||
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
|
||
pub enum RWAError {
|
||
/// 资产不存在
|
||
AssetNotFound,
|
||
/// 资产已存在
|
||
AssetAlreadyExists,
|
||
/// 无效的所有者
|
||
InvalidOwner,
|
||
/// 资产已冻结
|
||
AssetFrozen,
|
||
/// 未授权操作
|
||
Unauthorized,
|
||
/// 无效的资产DNA
|
||
InvalidAssetDNA,
|
||
/// 无效的GNACS编码
|
||
InvalidGNACSCode,
|
||
/// 估值过期
|
||
ValuationExpired,
|
||
/// 法律文件缺失
|
||
MissingLegalDocuments,
|
||
}
|
||
|
||
/// RWA资产状态
|
||
#[derive(Debug, Clone, Serialize, Deserialize)]
|
||
pub struct RWAState {
|
||
/// 资产映射 (asset_id -> RWAAssetInfo)
|
||
pub assets: HashMap<String, RWAAssetInfo>,
|
||
/// 所有者资产列表 (owner -> [asset_ids])
|
||
pub owner_assets: HashMap<String, Vec<String>>,
|
||
/// 资产DNA索引 (dna_hash -> asset_id)
|
||
pub dna_index: HashMap<String, String>,
|
||
/// GNACS索引 (gnacs_code -> [asset_ids])
|
||
pub gnacs_index: HashMap<String, Vec<String>>,
|
||
}
|
||
|
||
/// ACC-RWA接口
|
||
pub trait ACCRwa {
|
||
/// 注册RWA资产
|
||
fn register_asset(&mut self, asset_info: RWAAssetInfo) -> Result<(), RWAError>;
|
||
|
||
/// 获取RWA资产信息
|
||
fn get_asset(&self, asset_id: &str) -> Result<RWAAssetInfo, RWAError>;
|
||
|
||
/// 更新资产估值
|
||
fn update_valuation(&mut self, asset_id: &str, new_valuation: u128) -> Result<(), RWAError>;
|
||
|
||
/// 转移资产所有权
|
||
fn transfer_ownership(&mut self, asset_id: &str, new_owner: String) -> Result<(), RWAError>;
|
||
|
||
/// 冻结资产
|
||
fn freeze_asset(&mut self, asset_id: &str) -> Result<(), RWAError>;
|
||
|
||
/// 解冻资产
|
||
fn unfreeze_asset(&mut self, asset_id: &str) -> Result<(), RWAError>;
|
||
|
||
/// 注销资产
|
||
fn deactivate_asset(&mut self, asset_id: &str) -> Result<(), RWAError>;
|
||
|
||
/// 添加法律文件
|
||
fn add_legal_document(&mut self, asset_id: &str, document_hash: String) -> Result<(), RWAError>;
|
||
|
||
/// 获取所有者的资产列表
|
||
fn get_owner_assets(&self, owner: &str) -> Vec<RWAAssetInfo>;
|
||
|
||
/// 按GNACS编码查询资产
|
||
fn get_assets_by_gnacs(&self, gnacs_code: &str) -> Vec<RWAAssetInfo>;
|
||
|
||
/// 按资产类型查询资产
|
||
fn get_assets_by_type(&self, asset_type: RWAAssetType) -> Vec<RWAAssetInfo>;
|
||
|
||
/// 更新审计时间
|
||
fn update_audit_time(&mut self, asset_id: &str) -> Result<(), RWAError>;
|
||
}
|
||
|
||
/// ACC-RWA标准实现
|
||
#[derive(Debug, Clone, Serialize, Deserialize)]
|
||
pub struct RwaToken {
|
||
state: RWAState,
|
||
}
|
||
|
||
impl RwaToken {
|
||
/// 创建新的RWA资产管理器
|
||
pub fn new() -> Self {
|
||
Self {
|
||
state: RWAState {
|
||
assets: HashMap::new(),
|
||
owner_assets: HashMap::new(),
|
||
dna_index: HashMap::new(),
|
||
gnacs_index: HashMap::new(),
|
||
},
|
||
}
|
||
}
|
||
|
||
/// 获取状态的可变引用
|
||
pub fn state_mut(&mut self) -> &mut RWAState {
|
||
&mut self.state
|
||
}
|
||
|
||
/// 获取状态的不可变引用
|
||
pub fn state(&self) -> &RWAState {
|
||
&self.state
|
||
}
|
||
|
||
/// 生成资产DNA（简化实现）
|
||
fn generate_asset_dna(&self, asset_id: &str) -> String {
|
||
format!("DNA-{}", asset_id)
|
||
}
|
||
|
||
/// 验证资产DNA
|
||
fn validate_asset_dna(&self, dna: &str) -> bool {
|
||
dna.starts_with("DNA-") && dna.len() > 4
|
||
}
|
||
|
||
/// 验证GNACS编码
|
||
fn validate_gnacs_code(&self, code: &str) -> bool {
|
||
// 简化验证：检查格式（应为NAC-XXXX-XXXX格式）
|
||
code.starts_with("NAC-") && code.len() >= 8
|
||
}
|
||
}
|
||
|
||
impl Default for RwaToken {
|
||
fn default() -> Self {
|
||
Self::new()
|
||
}
|
||
}
|
||
|
||
impl ACCRwa for RwaToken {
|
||
fn register_asset(&mut self, mut asset_info: RWAAssetInfo) -> Result<(), RWAError> {
|
||
// 检查资产是否已存在
|
||
if self.state.assets.contains_key(&asset_info.asset_id) {
|
||
return Err(RWAError::AssetAlreadyExists);
|
||
}
|
||
|
||
// 验证GNACS编码
|
||
if !self.validate_gnacs_code(&asset_info.gnacs_code) {
|
||
return Err(RWAError::InvalidGNACSCode);
|
||
}
|
||
|
||
// 生成资产DNA
|
||
if asset_info.asset_dna.is_empty() {
|
||
asset_info.asset_dna = self.generate_asset_dna(&asset_info.asset_id);
|
||
}
|
||
|
||
// 验证资产DNA
|
||
if !self.validate_asset_dna(&asset_info.asset_dna) {
|
||
return Err(RWAError::InvalidAssetDNA);
|
||
}
|
||
|
||
let now = std::time::SystemTime::now()
|
||
.duration_since(std::time::UNIX_EPOCH)
|
||
.unwrap()
|
||
.as_secs();
|
||
|
||
asset_info.created_at = now;
|
||
asset_info.updated_at = now;
|
||
asset_info.status = RWAAssetStatus::Active;
|
||
|
||
let asset_id = asset_info.asset_id.clone();
|
||
let owner = asset_info.owner.clone();
|
||
let dna = asset_info.asset_dna.clone();
|
||
let gnacs_code = asset_info.gnacs_code.clone();
|
||
|
||
// 保存资产信息
|
||
self.state.assets.insert(asset_id.clone(), asset_info);
|
||
|
||
// 更新所有者资产列表
|
||
self.state
|
||
.owner_assets
|
||
.entry(owner)
|
||
.or_insert_with(Vec::new)
|
||
.push(asset_id.clone());
|
||
|
||
// 更新DNA索引
|
||
self.state.dna_index.insert(dna, asset_id.clone());
|
||
|
||
// 更新GNACS索引
|
||
self.state
|
||
.gnacs_index
|
||
.entry(gnacs_code)
|
||
.or_insert_with(Vec::new)
|
||
.push(asset_id);
|
||
|
||
Ok(())
|
||
}
|
||
|
||
fn get_asset(&self, asset_id: &str) -> Result<RWAAssetInfo, RWAError> {
|
||
self.state
|
||
.assets
|
||
.get(asset_id)
|
||
.cloned()
|
||
.ok_or(RWAError::AssetNotFound)
|
||
}
|
||
|
||
fn update_valuation(&mut self, asset_id: &str, new_valuation: u128) -> Result<(), RWAError> {
|
||
let mut asset = self.get_asset(asset_id)?;
|
||
|
||
if asset.status == RWAAssetStatus::Frozen {
|
||
return Err(RWAError::AssetFrozen);
|
||
}
|
||
|
||
let now = std::time::SystemTime::now()
|
||
.duration_since(std::time::UNIX_EPOCH)
|
||
.unwrap()
|
||
.as_secs();
|
||
|
||
asset.valuation_usd = new_valuation;
|
||
asset.updated_at = now;
|
||
|
||
self.state.assets.insert(asset_id.to_string(), asset);
|
||
|
||
Ok(())
|
||
}
|
||
|
||
fn transfer_ownership(&mut self, asset_id: &str, new_owner: String) -> Result<(), RWAError> {
|
||
let mut asset = self.get_asset(asset_id)?;
|
||
|
||
if asset.status == RWAAssetStatus::Frozen {
|
||
return Err(RWAError::AssetFrozen);
|
||
}
|
||
|
||
let old_owner = asset.owner.clone();
|
||
asset.owner = new_owner.clone();
|
||
|
||
let now = std::time::SystemTime::now()
|
||
.duration_since(std::time::UNIX_EPOCH)
|
||
.unwrap()
|
||
.as_secs();
|
||
asset.updated_at = now;
|
||
|
||
// 更新所有者资产列表
|
||
if let Some(assets) = self.state.owner_assets.get_mut(&old_owner) {
|
||
assets.retain(|id| id != asset_id);
|
||
}
|
||
self.state
|
||
.owner_assets
|
||
.entry(new_owner)
|
||
.or_insert_with(Vec::new)
|
||
.push(asset_id.to_string());
|
||
|
||
self.state.assets.insert(asset_id.to_string(), asset);
|
||
|
||
Ok(())
|
||
}
|
||
|
||
fn freeze_asset(&mut self, asset_id: &str) -> Result<(), RWAError> {
|
||
let mut asset = self.get_asset(asset_id)?;
|
||
|
||
let now = std::time::SystemTime::now()
|
||
.duration_since(std::time::UNIX_EPOCH)
|
||
.unwrap()
|
||
.as_secs();
|
||
|
||
asset.status = RWAAssetStatus::Frozen;
|
||
asset.updated_at = now;
|
||
|
||
self.state.assets.insert(asset_id.to_string(), asset);
|
||
|
||
Ok(())
|
||
}
|
||
|
||
fn unfreeze_asset(&mut self, asset_id: &str) -> Result<(), RWAError> {
|
||
let mut asset = self.get_asset(asset_id)?;
|
||
|
||
let now = std::time::SystemTime::now()
|
||
.duration_since(std::time::UNIX_EPOCH)
|
||
.unwrap()
|
||
.as_secs();
|
||
|
||
asset.status = RWAAssetStatus::Active;
|
||
asset.updated_at = now;
|
||
|
||
self.state.assets.insert(asset_id.to_string(), asset);
|
||
|
||
Ok(())
|
||
}
|
||
|
||
fn deactivate_asset(&mut self, asset_id: &str) -> Result<(), RWAError> {
|
||
let mut asset = self.get_asset(asset_id)?;
|
||
|
||
let now = std::time::SystemTime::now()
|
||
.duration_since(std::time::UNIX_EPOCH)
|
||
.unwrap()
|
||
.as_secs();
|
||
|
||
asset.status = RWAAssetStatus::Deactivated;
|
||
asset.updated_at = now;
|
||
|
||
self.state.assets.insert(asset_id.to_string(), asset);
|
||
|
||
Ok(())
|
||
}
|
||
|
||
fn add_legal_document(&mut self, asset_id: &str, document_hash: String) -> Result<(), RWAError> {
|
||
let mut asset = self.get_asset(asset_id)?;
|
||
|
||
let now = std::time::SystemTime::now()
|
||
.duration_since(std::time::UNIX_EPOCH)
|
||
.unwrap()
|
||
.as_secs();
|
||
|
||
asset.legal_documents.push(document_hash);
|
||
asset.updated_at = now;
|
||
|
||
self.state.assets.insert(asset_id.to_string(), asset);
|
||
|
||
Ok(())
|
||
}
|
||
|
||
fn get_owner_assets(&self, owner: &str) -> Vec<RWAAssetInfo> {
|
||
self.state
|
||
.owner_assets
|
||
.get(owner)
|
||
.map(|asset_ids| {
|
||
asset_ids
|
||
.iter()
|
||
.filter_map(|id| self.state.assets.get(id).cloned())
|
||
.collect()
|
||
})
|
||
.unwrap_or_default()
|
||
}
|
||
|
||
fn get_assets_by_gnacs(&self, gnacs_code: &str) -> Vec<RWAAssetInfo> {
|
||
self.state
|
||
.gnacs_index
|
||
.get(gnacs_code)
|
||
.map(|asset_ids| {
|
||
asset_ids
|
||
.iter()
|
||
.filter_map(|id| self.state.assets.get(id).cloned())
|
||
.collect()
|
||
})
|
||
.unwrap_or_default()
|
||
}
|
||
|
||
fn get_assets_by_type(&self, asset_type: RWAAssetType) -> Vec<RWAAssetInfo> {
|
||
self.state
|
||
.assets
|
||
.values()
|
||
.filter(|asset| asset.asset_type == asset_type)
|
||
.cloned()
|
||
.collect()
|
||
}
|
||
|
||
fn update_audit_time(&mut self, asset_id: &str) -> Result<(), RWAError> {
|
||
let mut asset = self.get_asset(asset_id)?;
|
||
|
||
let now = std::time::SystemTime::now()
|
||
.duration_since(std::time::UNIX_EPOCH)
|
||
.unwrap()
|
||
.as_secs();
|
||
|
||
asset.last_audited_at = Some(now);
|
||
asset.updated_at = now;
|
||
|
||
self.state.assets.insert(asset_id.to_string(), asset);
|
||
|
||
Ok(())
|
||
}
|
||
}
|
||
|
||
#[cfg(test)]
|
||
mod tests {
|
||
use super::*;
|
||
|
||
fn create_test_asset() -> RWAAssetInfo {
|
||
RWAAssetInfo {
|
||
asset_id: "RWA-001".to_string(),
|
||
asset_type: RWAAssetType::RealEstate,
|
||
name: "Test Property".to_string(),
|
||
description: "A test real estate asset".to_string(),
|
||
asset_dna: String::new(),
|
||
gnacs_code: "NAC-RE-001".to_string(),
|
||
owner: "alice".to_string(),
|
||
valuation_usd: 1000000_00,
|
||
status: RWAAssetStatus::Pending,
|
||
physical_location: Some("123 Main St".to_string()),
|
||
legal_documents: vec!["doc1".to_string()],
|
||
created_at: 0,
|
||
updated_at: 0,
|
||
last_audited_at: None,
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn test_register_asset() {
|
||
let mut rwa = RwaToken::new();
|
||
let asset = create_test_asset();
|
||
assert!(rwa.register_asset(asset).is_ok());
|
||
}
|
||
|
||
#[test]
|
||
fn test_update_valuation() {
|
||
let mut rwa = RwaToken::new();
|
||
let asset = create_test_asset();
|
||
rwa.register_asset(asset).unwrap();
|
||
|
||
assert!(rwa.update_valuation("RWA-001", 1200000_00).is_ok());
|
||
assert_eq!(rwa.get_asset("RWA-001").unwrap().valuation_usd, 1200000_00);
|
||
}
|
||
|
||
#[test]
|
||
fn test_transfer_ownership() {
|
||
let mut rwa = RwaToken::new();
|
||
let asset = create_test_asset();
|
||
rwa.register_asset(asset).unwrap();
|
||
|
||
assert!(rwa.transfer_ownership("RWA-001", "bob".to_string()).is_ok());
|
||
assert_eq!(rwa.get_asset("RWA-001").unwrap().owner, "bob");
|
||
}
|
||
|
||
#[test]
|
||
fn test_freeze_unfreeze_asset() {
|
||
let mut rwa = RwaToken::new();
|
||
let asset = create_test_asset();
|
||
rwa.register_asset(asset).unwrap();
|
||
|
||
assert!(rwa.freeze_asset("RWA-001").is_ok());
|
||
assert_eq!(rwa.get_asset("RWA-001").unwrap().status, RWAAssetStatus::Frozen);
|
||
|
||
assert!(rwa.unfreeze_asset("RWA-001").is_ok());
|
||
assert_eq!(rwa.get_asset("RWA-001").unwrap().status, RWAAssetStatus::Active);
|
||
}
|
||
|
||
#[test]
|
||
fn test_add_legal_document() {
|
||
let mut rwa = RwaToken::new();
|
||
let asset = create_test_asset();
|
||
rwa.register_asset(asset).unwrap();
|
||
|
||
assert!(rwa.add_legal_document("RWA-001", "doc2".to_string()).is_ok());
|
||
assert_eq!(rwa.get_asset("RWA-001").unwrap().legal_documents.len(), 2);
|
||
}
|
||
|
||
#[test]
|
||
fn test_get_owner_assets() {
|
||
let mut rwa = RwaToken::new();
|
||
let asset = create_test_asset();
|
||
rwa.register_asset(asset).unwrap();
|
||
|
||
let assets = rwa.get_owner_assets("alice");
|
||
assert_eq!(assets.len(), 1);
|
||
}
|
||
|
||
#[test]
|
||
fn test_get_assets_by_gnacs() {
|
||
let mut rwa = RwaToken::new();
|
||
let asset = create_test_asset();
|
||
rwa.register_asset(asset).unwrap();
|
||
|
||
let assets = rwa.get_assets_by_gnacs("NAC-RE-001");
|
||
assert_eq!(assets.len(), 1);
|
||
}
|
||
}
|