NAC_Blockchain/nvm_v2/nvm-l1/tests/integration_test.rs

// NAC公链完整集成测试
// 测试资产上链权益化的完整闭环

#[cfg(test)]
mod integration_tests {
    use nvm_l1::asset_management::{AssetCertificate, AssetCertificateRegistry, XTZHStakingManager};
    use nvm_l1::assetization::{EquityAsset, EquityAssetRegistry};
    
    #[test]
    fn test_complete_asset_tokenization_flow() {
        println!("\n========== NAC公链资产上链权益化完整闭环测试 ==========\n");
        
        // 1. 资产申请上链
        println!("步骤1: 资产申请上链");
        let asset_owner = vec![1u8; 20];
        let asset_data = "商业地产-北京CBD核心区A座".as_bytes().to_vec();
        let asset_value = 5_000_000; // 500万美元
        
        // 2. 资产估值流程
        println!("步骤2: 资产估值完成 - ${}", asset_value);
        
        // 3. 获得链上确权 - 生成资产TOKEN
        println!("步骤3: 链上确权 - 生成资产TOKEN");
        let mut token_registry = AssetCertificateRegistry::new();
        
        let asset_token = AssetCertificate::new(
            asset_data.clone(),
            asset_owner.clone(),
            asset_value,
            1234567890,
        );
        
        let token_id = asset_token.token_id.clone();
        println!("   TOKEN ID: 0x{}", hex::encode(&token_id[..8]));
        println!("   DNA哈希: 0x{}", hex::encode(&asset_token.asset_dna[..8]));
        
        token_registry.register(asset_token).unwrap();
        
        // 4. XTZH质押（80%规则）
        println!("\n步骤4: XTZH质押（80%规则）");
        let mut staking_manager = XTZHStakingManager::new();
        
        let xtzh_amount = (asset_value * 80) / 100; // 质押80%
        println!("   需要质押: {} XTZH", xtzh_amount);
        
        let stake_id = staking_manager.stake(
            token_id.clone(),
            asset_owner.clone(),
            xtzh_amount,
            asset_value,
            1234567891,
        ).unwrap();
        
        println!("   质押ID: 0x{}", hex::encode(&stake_id[..8]));
        
        // 验证80%规则
        let stake = staking_manager.get_stake(&stake_id).unwrap();
        assert!(stake.meets_80_percent_rule());
        println!("   ✓ 满足80%规则");
        
        // 5. 铸造权益化代币
        println!("\n步骤5: 发行权益化资产代币");
        let mut equity_registry = EquityAssetRegistry::new();
        
        let equity_token = EquityAsset::new(
            "CBD Commercial Real Estate Asset".to_string(),
            "CBDRE".to_string(),
            18,
            asset_value, // 总供应量等于资产估值
            token_id.clone(),
            stake_id.clone(),
            asset_owner.clone(),
            1234567892,
        );
        
        println!("   代币名称: {}", equity_token.name);
        println!("   代币符号: {}", equity_token.symbol);
        println!("   总供应量: {}", equity_token.total_supply);
        println!("   合约地址: 0x{}", hex::encode(&equity_token.contract_address[..8]));
        
        equity_registry.register(equity_token.clone()).unwrap();
        
        // 标记质押已用于发行
        staking_manager.mark_issued(&stake_id).unwrap();
        
        // 6. 测试代币转账
        println!("\n步骤6: 代币交易测试");
        let buyer = vec![2u8; 20];
        let transfer_amount = 100_000;
        
        {
            let asset = equity_registry.get_mut(&equity_token.contract_address).unwrap();
            asset.transfer(&asset_owner, buyer.clone(), transfer_amount).unwrap();
            println!("   ✓ 转账成功: {} CBDRE", transfer_amount);
            println!("   所有者余额: {}", asset.balance_of(&asset_owner));
            println!("   买家余额: {}", asset.balance_of(&buyer));
        }
        
        // 7. 验证完整闭环
        println!("\n========== 闭环验证 ==========");
        
        // 闭环1: 资产TOKEN生成
        let retrieved_token = token_registry.get(&token_id).unwrap();
        assert_eq!(retrieved_token.asset_value, asset_value);
        println!("✓ 闭环1: 资产TOKEN生成 - 通过");
        
        // 闭环2: XTZH质押机制
        let retrieved_stake = staking_manager.get_stake(&stake_id).unwrap();
        assert!(retrieved_stake.is_used_for_issuance);
        println!("✓ 闭环2: XTZH质押机制（80%规则）- 通过");
        
        // 闭环3: 权益化代币发行
        let retrieved_equity = equity_registry.get(&equity_token.contract_address).unwrap();
        assert_eq!(retrieved_equity.total_supply, asset_value);
        println!("✓ 闭环3: 权益化代币发行 - 通过");
        
        // 闭环4: 代币流通
        let asset = equity_registry.get(&equity_token.contract_address).unwrap();
        assert_eq!(asset.balance_of(&buyer), transfer_amount);
        println!("✓ 闭环4: 代币流通交易 - 通过");
        
        // 闭环5: 链上确权
        assert_eq!(retrieved_token.owner, asset_owner);
        println!("✓ 闭环5: 链上确权 - 通过");
        
        println!("\n========== 所有闭环测试通过！==========\n");
    }
    
    #[test]
    fn test_multiple_assets_flow() {
        println!("\n========== 多资产并发测试 ==========\n");
        
        let mut token_registry = AssetCertificateRegistry::new();
        let mut staking_manager = XTZHStakingManager::new();
        let mut equity_registry = EquityAssetRegistry::new();
        
        // 创建3个不同的资产
        let assets = vec![
            ("商业地产", 5_000_000),
            ("艺术品收藏", 2_000_000),
            ("知识产权", 1_000_000),
        ];
        
        for (index, (name, value)) in assets.iter().enumerate() {
            println!("资产{}: {} - ${}", index + 1, name, value);
            
            let owner = vec![(index + 1) as u8; 20];
            let asset_data = name.as_bytes().to_vec();
            
            // 生成TOKEN
            let asset_token = AssetCertificate::new(
                asset_data,
                owner.clone(),
                *value,
                1234567890 + index as u64,
            );
            let token_id = asset_token.token_id.clone();
            token_registry.register(asset_token).unwrap();
            
            // 质押XTZH
            let xtzh_amount = (value * 80) / 100;
            let stake_id = staking_manager.stake(
                token_id.clone(),
                owner.clone(),
                xtzh_amount,
                *value,
                1234567891 + index as u64,
            ).unwrap();
            
            // 发行代币
            let symbol = format!("ASSET{}", index + 1);
            let equity_token = EquityAsset::new(
                name.to_string(),
                symbol,
                18,
                *value,
                token_id,
                stake_id.clone(),
                owner,
                1234567892 + index as u64,
            );
            equity_registry.register(equity_token).unwrap();
            
            staking_manager.mark_issued(&stake_id).unwrap();
            
            println!("   ✓ 完成");
        }
        
        // 验证统计
        let token_stats = token_registry.stats();
        let staking_stats = staking_manager.stats();
        let equity_stats = equity_registry.stats();
        
        println!("\n统计信息:");
        println!("  资产TOKEN数: {}", token_stats.total_tokens);
        println!("  XTZH质押总量: {}", staking_stats.total_xtzh_staked);
        println!("  权益代币数: {}", equity_stats.total_tokens);
        println!("  总资产价值: ${}", token_stats.total_value);
        
        assert_eq!(token_stats.total_tokens, 3);
        assert_eq!(staking_stats.issued_stakes, 3);
        assert_eq!(equity_stats.total_tokens, 3);
        
        println!("\n========== 多资产并发测试通过！==========\n");
    }
}